Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

1.执行脚本的两种方式

Python a.py 直接调用Python解释器执行文件

chomd +x a.py ./a.py #修改a.py文件的属性，为可执行，在用 ./ 执行a.py 文件

2、简述位、字节的关系

1bytes=8bit ,2**8=256,可以代表256中变化，

3、简述 ascii、unicode、utf-8、gbk 的关系

ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符，

Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，

可以用在内存处理中，兼容了utf-8，gbk，ASCII，

utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的，

gbk 是中文的字符编码，用2个字节代表一个字符，

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8 是3 bytes=24bit

gbk 是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释 #

多行注释 """ """三个双引号或是三个单引号把要解释的内容放中间， ‘’‘ ’’’

6、声明变量注意事项有那些?

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码
2 B( x* |$ Y( ~( I+ z3 ua.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :" e. l+ B2 J5 P1 U: j
name = input('name:').strip()
1 e; K% S$ Q% w% n, ~4 Z% q pwd = input('pwd：').strip(), f& K' {! n/ Q0 |( ?
1 n9 H0 r2 Y# k
if name=='seven' and pwd=='123' :* P) b* U) T- V, `2 d4 d- q
      print('ok'); ?0 I  y+ U, k( G# h2 o
else:
" s9 r" Z+ e2 C. K. ^: @: d  k       print('error')
- r: @0 P" J6 C+ n       count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :3 o, c$ M/ X+ ~9 M% t
name = input('name: ')3 d! K% K/ C5 {
pwd = input('pwd: ')
" W* D$ _8 a* u2 d* Z+ h# G) l if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':. H9 k9 P6 J4 f2 L' o
      print('ok')* L5 H5 H8 z# [8 ^  I9 u/ A3 X
else :) D. a7 Q% {) @, |7 [5 d( t
      print('error')
- E* r( a& g' _  |       count+=111、写代码. P+ [7 \% ~7 ^4 e; H. q( R
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
: t# x& g1 D/ ?0 K- x if i %2 != 0 :( n- {7 J4 L& K7 O) [3 G% N% T
      print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :; }6 `2 P3 k, h0 e1 B: _; Y
if i %2 == 0:
9 d& p8 o2 d2 F8 H       print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制 0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1)) 结果 3

18、布尔值分别有什么?

False .Ture ,或1 和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"( p. O6 \. ]; P; O  Q) e4 V2 j* j4 S
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p')) apex
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e')) ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name)
) Y$ q: \& U: Nfor i in name:' i# \8 w0 B# t0 m$ Q
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain- i6 R$ e1 V/ ?7 U; P4 {
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']/ H1 b  t( Q1 a- Y) p8 o5 x" R: g
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
; O4 C' Z0 F8 B3 k" F4 X) _, gprint(li)
- H( V5 ]( v1 V5 S1 o$ B ['alex', 'eric', 'rain', 'seven']
: I" Z' n. Z7 C5 H. J- L* ?- `) P: W& lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')2 n1 s% m+ U+ q0 D
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'); J& G5 b7 [: O- ?
print(li)
1 e; c* e: y: ^6 re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']6 ~' H0 @6 X* S
li.pop(1)0 ^# q* a5 r" ^) ~' d
print(li) ['alex', 'rain']
6 T; K' s' j  Q5 n2 Q/ {指名道姓的删除li = ['alex', 'eric', 'rain']
1 t2 c; K5 M& l" Nli.remove('alex')
: p/ i. z) b$ R& p3 c( Pprint(li)( J; J- `$ Q, E- T7 D- N$ d- q) ?" G
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! ?' Q' C' R5 Q* F0 B- T& Y/ z7 r& qprint(li.pop(1))
8 a2 P  q9 _8 }print(li)6 z8 r% X1 F3 r0 v& G
2 S. G, c/ N+ w
eric
4 G  m: A# V: U) J7 b1 c['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
; R( T& Q  M4 w- q6 r4 ~del li[1:]
. t) z5 K/ N  Y9 Kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
8 b6 [& |& a& Bli = ['alex', 'eric', 'rain']$ [: s9 H6 ^' W. j2 I* b
for k,v in enumerate(li,1):+ S# ^9 N$ y8 V4 G" `9 m7 [% k% s- |! \
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# n& R5 ^2 A6 w# u  @% d9 S0 Ia. 请输出 “Kelly”
$ T; @# B' I# w8 [4 Z4 P: Rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ g0 b- ^5 C7 b1 r& J4 jprint(li[2][1][1])4 n: v& s( e/ Q5 w4 L  j& R
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 n5 `6 s3 T$ ^6 B0 sli[2][2]='ALL'
+ h9 [' ~8 n0 K3 M+ Qprint(li)
. ^8 `' J4 {8 g8 J7 Q( T8 l' j9 Q24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')  M+ c7 A' u7 c4 M, A4 k4 P
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')& _4 e. }* t  t
print(len(tu))0 N, o# S) F+ Z" K0 o
b. 获取元组的第 2 个元素，并输出
# z! D: H/ Q$ r6 Y/ Y- k+ J/ jprint(tu[1])
5 G8 ^2 f+ x! |* z# r5 re. 请使用 for、len、range 输出元组的索引* w- L5 [5 w1 u7 z6 ?1 g
for i in range(len(tu)) :8 h7 Q9 {4 p9 ?0 w& V
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 o8 g3 v; Y& T# ^( B2 A2 ^( u- vfor k,v in enumerate(tu,10) :( \4 ~9 |  t5 j9 i
print(k,v)! `9 t" P4 F2 B& m/ {8 R8 G
10 alex
2 W# P7 l; V, [: }0 H11 eric
& \3 i( X5 ^2 Y& J) A. d12 rain
% ?7 O7 s8 x# O2 o
: I7 ^/ b9 b+ Zfor k in enumerate(tu,10) :
, j) F' ^. O+ m& x$ z print(k)
4 Y  L9 ^! u1 {$ d$ F# [(10, 'alex')) \( R4 v1 N. h$ B
(11, 'eric')% u" B; p' z& F% |
(12, 'rain')
$ o$ }6 S/ l, m- X+ S* O4 |8 T* W0 Z; r5 j+ q8 y) |% I. e5 Z9 W
) }# U1 C/ E2 ~9 o# ~* N/ x
25、有如下变量，请实现要求的功能
8 d, a" G# _. q7 t7 _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
$ ?$ w- S( x/ J; a% B. A! j
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以5 ^7 i9 L( g; t( b& Y
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])% @  Z" N1 O/ L/ {5 a3 ?, |
res=tu[1][2]['k2'].append('seven')
! |/ U8 J$ |+ q& U8 d, M6 H( x% Y3 V; c+ }
print(tu)
& h& l+ E4 [5 E$ c26、字典, A! T1 t( r1 {
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  g5 b$ A( g) N9 t: F6 d1 H; g/ i print(i)b. 请循环输出所有的 value
% q) n0 U2 W: p8 B" a5 l7 t6 M/ Efor i in dic:
5 H2 H1 g5 R" \7 a print(dic)
# o/ ]6 Q2 e1 Q5 hc. 请循环输出所有的 key 和 valuefor i in dic:
% o6 S, o: G, r# D- x% U% R$ |2 \4 F, gprint(i,dic)9 ~9 v4 Z+ `: K) `/ Y
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
$ K9 U( l0 w; m; Cdic['k4']='v4'
% Y# h  k  M9 i8 k8 w7 C- d* }print(dic)
& a0 S# l; q9 ?5 X. v) he. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  K: G, m0 {9 e# [
dic['k1']='alex'
3 A6 V$ F3 h5 l+ ?1 B, dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典% w. m" ~% o! l5 `) ]# J( o- j
dic['k3'].append(44); V9 Q7 r* M) g% K
print(dic), _% T# h, X! c: I" q  G" c

  a; F# c! Q8 o# Y/ c! ^8 [g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( X6 K; }6 I6 i7 P2 Adic['k3'].insert(0,44)
7 t5 o1 U4 R0 sprint(dic)( f8 _& E/ t) r9 z! P: c; \
27、转换
4 ?( u4 N7 O( M' H" x' {8 b' Ya. 将字符串 s = "alex" 转换成列表  s = "alex"; n2 x5 W+ T1 r) x

1 ~' c5 v. j% Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖, |5 Q( U+ a  B! g, w) ^# `2 b
s = "alex"
# b8 ?8 H# M/ ~7 h2 y0 uprint(tuple(s))5 A/ c5 H4 Y' ~. m( e. Y

3 ?! M3 W5 u+ Xb. 将列表 li = ["alex", "seven"] 转换成元组& W) r4 I* X8 Z/ N6 m6 p$ T
li = ["alex", "seven"]
5 Y* h0 d" e" C! y; Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表% [# ~6 t% n/ w; m% n. Z7 _
tu = ('Alex', "seven")
% |( T; {+ T3 D, Z5 Jli=list(tu)% [, G  t0 ]' H0 `
print(li)  }+ m0 e0 d7 t4 E5 N+ w
0 q/ m' J7 ?4 j" d" @

% z6 [% c2 J' e3 Q8 u7 jd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
/ p* `) t& h4 R8 {: |# L7 D8 X4 M2 p: W- d' u
dic={}6 f1 M& P; S' n  r7 z
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
8 X3 n# z8 b% o! }! j4 F dic[k]=v
: g5 r% D$ f$ O4 U print(dic)27、转码n = "老男孩"
# {; s9 {4 X' Ka. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"0 E: s$ T& X6 k1 e, e+ d
a=n.encode('utf-8') / l  ?( O5 S$ X" @: K
print(a)3 t0 j" a& }+ c: @, L
b=a.decode('utf-8')9 k; O' M  z! Y1 Y  C
print(b)
) J5 s/ J! M2 l9 l" a, t; ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
# T- t6 E! v  j& }- oprint(a)
4 [4 b0 y3 A* h" H. Tb=a.decode('gbk')+ w: \5 y  n5 |0 e! Q
print(b)28、求 1-100 内的所有数的和
2 [6 O2 J; _1 B. f$ icount=1
6 x1 G5 O: ^; Z2 tsum=0; Y. [- l! }: ^# o5 r- X
for i in range(100) :
  P$ a4 g: i5 G4 Z sum=sum+count
4 G. @: Q/ H* \0 L count+=19 R9 n2 k' n1 X6 E' H
print(sum)1 [4 P4 b8 R% k) F

7 b" @+ N7 D+ o# v- Scount=10 E' M6 ]& R% p2 m5 {2 e* s8 V. q  t
sum=0
2 X3 r) @5 ^; D7 t! |while count<=100 :
0 s4 C6 I# K; n0 ^4 v/ m sum+=count
" p7 c$ M1 G7 m; ]2 [+ I count+=1- y$ e- }$ r8 Y: e: T# R- D' x
print(sum)29、元素分类
! j: O; x1 v% S6 A  V有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，3 N' j% s4 P) N7 l
将小于 66 的值保存至第二个 key 的值中。; {2 {5 M9 t+ l6 j
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}' a+ q4 t- _' @/ j9 b2 e; W& G
li=[11,22,33,44,55,66,77,88,99,90]
: f3 _1 |5 c2 N4 Z8 b, Idic1={+ |, r, ]- z8 H4 _8 f1 _0 P
'max':[],
+ V! J- q! F: ^3 h, y; _3 N+ Z4 J 'min':[]3 @0 S: f; d* Y5 |# Y* F4 l
}: `! T6 r; }; k& e3 s) s# Q
for i in li :* Y: c6 N0 M3 H0 s$ z7 ]% t
if i <66 :; t2 q- Z6 {" ?% i7 m/ W
      dic1['min'].append(i)
' r+ m' p0 m2 Q else:  i+ ]' `. r5 S- ^4 ?. s4 L
      dic1['max'].append(i)
) R' r5 l* q) A% H* _! Q! j1 dprint(dic1)
; c" o$ E9 G* B0 N0 x" E4 W# i) E: \
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}- s4 w( \$ g- A3 \* j

Python基础知识汇总

主题推荐