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 [: D2 q+ d' y/ Y: \& I% b- j: B8 O; ]a.实现用户输入用户名和密码，当用户名为 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) :7 V. k. y7 O' d0 `, ]
name = input('name:').strip()
2 ^  p7 ~7 i0 b, l2 t pwd = input('pwd：').strip()
$ i5 k% ]! y8 j  d
1 z3 O: T0 X: b4 R. V7 d' N if name=='seven' and pwd=='123' :! O& s# x. @# d- Q+ w7 Q: y+ Q
      print('ok'), N4 Q4 J+ N, A
else:8 h% g1 B/ E' S: g1 {: _: R, c
      print('error')
. p/ Y/ ]8 l: T4 C       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)  :9 v, t/ t- y5 N( r8 W. }  j
name = input('name: ')  l- R5 ~- R* S$ ~& I
pwd = input('pwd: ')/ a' _/ b+ O2 c. z6 X& M
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':9 ]" m% M" F( @, ^9 ^
      print('ok')0 l4 b) F9 T+ M$ Q9 s
else :
" p1 ^# x% R3 r7 Z( ~( a, R       print('error'), y' O! Z" k- o; Q3 K8 K
      count+=111、写代码
- o% x  S7 g0 t% Z* U+ L+ ja. 使用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) :! m: r5 x, s" t: T% @3 H
if i %2 != 0 :
; K- ^+ g+ M: V       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* `- T% P7 s: a if i %2 == 0:
& f! [1 }* Q1 U2 s4 y$ U       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"
+ i! b" L& |$ U- m! b! Q7 Ia. 移除 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)
& H$ w: q9 J4 G+ S; afor i in name:. O' A9 ?' Q; `4 P* D- r
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain5 Q9 n% i. _& y% H
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
5 g0 ]) @9 z0 Xprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 t$ G( g7 l9 _4 ]$ \
print(li)
1 I6 S* i6 ~5 Q0 `# o! w/ a# P ['alex', 'eric', 'rain', 'seven']# s$ d) Z; H5 u; o: e8 X
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( I- n$ t. a: e- \: [" j
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')) K# e$ E/ }7 w# h2 x! p
print(li)
: |4 b% P9 m4 |+ p* Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
4 H; f% V5 ~% V0 Yli.pop(1)
. \* D+ v9 _! @1 W0 X+ `* _. F2 U4 iprint(li) ['alex', 'rain']
  j1 n& h  ?- l! B$ H指名道姓的删除li = ['alex', 'eric', 'rain']1 g; E) B9 ?! G7 p/ y* B
li.remove('alex')
1 [# P7 j' J* _4 f( sprint(li)
( v2 |% q  @! N6 M8 P9 vf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 I! ^+ O- g* c$ e6 f, a& zprint(li.pop(1))
' s* _8 g3 D; {' O, g: vprint(li)
. N" c2 B: _# Q: c4 ?& y; i' U) n' ~$ j" N7 h
eric
* k0 c$ h- m: S* J6 i['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. f) Z: M% p, ?& V" o& c! n8 v/ K
del li[1:]4 M; G8 z+ r* ]$ r6 K$ x
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)+ C( y& w# N5 t6 l
li = ['alex', 'eric', 'rain']
: T6 f' K8 ?% r5 L  H. hfor k,v in enumerate(li,1):0 y/ X+ i" z( g. L& o
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: t6 J$ ]0 }  o' j# r8 q5 G. g  ta. 请输出 “Kelly”# _7 P% a5 D& p9 Z# B
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 |( ^$ k! ]- y+ J- V0 v& S7 jprint(li[2][1][1])2 A0 k5 M% h( G
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”0 P& k; d7 b7 x0 U5 ]$ Z) J! L1 L
li[2][2]='ALL'; E/ U( I9 l% }" z5 F- l% {7 R
print(li)
; W( ~- b% F: \! {$ ]2 m  \  F) S24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! m* s, U. Q8 o0 Q. Z' }% ]$ Ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
# q) L1 m  _8 A2 ]; ^% {7 {print(len(tu))# ^# @1 g& U, ~4 F/ V# G. y
b. 获取元组的第 2 个元素，并输出
9 w( H" U0 P! ?% p0 s. l  b2 lprint(tu[1])5 g3 x$ x+ ]$ q1 ^1 k. K
e. 请使用 for、len、range 输出元组的索引
. e" e: v( B+ M% Ifor i in range(len(tu)) :: L2 P3 a7 Z) b8 h8 O
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)' U, S/ e2 X3 R
for k,v in enumerate(tu,10) :
0 r' I5 E. D- D" C* {& q+ } print(k,v)9 k  g1 p  S1 M8 _0 i7 I
10 alex# z( x' }$ J3 P: [
11 eric
" w+ b" `" a8 R8 k) s" c12 rain
" \, X2 P/ M5 E  d  k( R0 g/ {6 G5 x- B3 B
for k in enumerate(tu,10) :1 G5 G0 j& c3 N6 T9 @+ B! m2 j
print(k)
  @! n% I* b, s" f6 {(10, 'alex')
* @0 f: x) q5 v5 \+ R* u. n(11, 'eric'), V7 h6 u! E7 t1 F" h; ?
(12, 'rain')6 Z2 O4 X5 m( m$ y. X. Q+ G

$ @) ]2 V. t' [9 n2 P' e, z9 p& Y$ n: Q4 |
25、有如下变量，请实现要求的功能
/ |* x3 ~" f, G# {, Q' ?/ rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 A- g) e4 ^7 a: p$ Y& I6 u0 Ed. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. M) l/ l% h1 A$ k6 Jtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])5 K, J! Q7 w6 M
res=tu[1][2]['k2'].append('seven')
' g) m9 b, h. L2 h- S1 j2 Y" z" _
4 W* w$ ~  I6 b. Hprint(tu)4 z* ]  c6 T) K" u
26、字典
2 y4 ]4 P/ T: [/ E& b! {; Odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:$ M% a; A( q# q7 n. v' T2 y5 @
print(i)b. 请循环输出所有的 value
7 ], L- I& \  H9 W0 I7 P  u. Rfor i in dic:: \8 d% u: n" S7 h' M
print(dic)
5 E- `* Y* Q" Q' S7 p; g- ]( n6 p6 Vc. 请循环输出所有的 key 和 valuefor i in dic:
  U, S" F  p& sprint(i,dic)
! I: D! I2 X* n$ h' B1 Ed. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典/ m( i9 l+ ?; }: m8 W! U
dic['k4']='v4'! m/ n: B7 n8 \; u* S
print(dic)3 I6 `8 F; K( f5 [5 @% J) N- v+ u& P. g
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 ^2 y* C, d' \) Qdic['k1']='alex'
6 R$ t. ]7 O% V* w) b2 lprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典* K7 i- w3 Y/ b) U
dic['k3'].append(44)
  j6 A" |1 c. [4 Hprint(dic)4 C# r  ?) z8 P$ e& @6 Z5 Q& D2 z+ A
1 i; |& d  B4 e9 e" _! _5 g) [9 Z
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
9 t1 N, c% t# D. K# W, K( H8 b# Udic['k3'].insert(0,44)3 I5 Y3 J( p8 G& K2 J8 w
print(dic)6 ~8 c* T3 `- u6 f/ R% }7 }7 B9 W
27、转换
  }" u( o. o  B) Ca. 将字符串 s = "alex" 转换成列表  s = "alex"
5 B# O3 f) o& B( W% Y9 U3 y/ T9 y
print(list(s))b. 将字符串 s = "alex" 转换成元祖
3 y- c' B% j- w' W$ n5 js = "alex"
9 x  h- [7 m, f+ w* v+ Xprint(tuple(s))
# y9 w3 c" [. x3 s$ L7 {! d& Z( z
1 L! X: ^) l0 p: p' P& L: `0 q8 jb. 将列表 li = ["alex", "seven"] 转换成元组
2 {" Y+ F/ w& Q" \li = ["alex", "seven"]* q: _2 `/ G- Q$ m7 g6 g7 r
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- Y, _) ^2 h( o' t8 L3 O! u4 y- stu = ('Alex', "seven")
9 _* n& O( h0 Y1 |. |1 u( Tli=list(tu)
* N2 L, |9 Z, O- n0 Xprint(li)* |, v, T2 m7 z, E1 F

% x- G* t  H# G$ n# U1 o' ?
8 S' p% |0 i5 D! r+ J! nd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增) i. \0 L* }% e4 ?1 h

# x- \8 `3 N5 y5 A( B: P1 Zdic={}
) F3 }) k! C5 [' x3 d. Wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. N6 Y7 f3 u* }; R4 N dic[k]=v. V6 d2 j' `. q0 ^& x
print(dic)27、转码n = "老男孩"
! ^! v% w2 U* Y/ da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"& k3 g* e! v, i, d9 q4 @% t) p
a=n.encode('utf-8')
7 V: }7 W& S" I6 |6 nprint(a)
- H! R" b( A* K3 {b=a.decode('utf-8')
$ A- ~) K0 R1 E- U6 [" R4 O% cprint(b)
0 v, R2 u1 y* W! i8 o2 h- rb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')  }1 a' l6 \0 p: g" Y  \
print(a)4 m) |: g' p7 a- D! i2 w/ G
b=a.decode('gbk')2 c+ G* ^# f/ r7 f& A1 j9 C
print(b)28、求 1-100 内的所有数的和
$ H; W0 S9 R$ G* C* _6 ^count=16 R* c6 T7 H. Z1 E2 b, R9 r* }
sum=0
8 Y# Q7 _) V1 c" Ifor i in range(100) :
7 u: S: ]  m0 C3 s# K- L" O sum=sum+count
, y; Z8 I3 J& U3 m) ^ count+=1
2 u# u2 ]3 A, `# q- n# @: w# V, M9 t' rprint(sum)
. `  D  o5 \3 a0 q, f( G7 ]
" g9 w& l" q. Rcount=1$ A6 d; `, c9 f9 D
sum=09 N( i9 @4 \& s. h$ H
while count<=100 :# {3 B' u1 B9 h* @
sum+=count
! E7 Q' [& G4 H/ z+ ~ count+=1
5 w3 Q3 m0 G; w: j) Fprint(sum)29、元素分类
7 G  l1 B! ?. i1 L: B3 @/ y" K有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 W% Y: r! m* `+ |- B2 z将小于 66 的值保存至第二个 key 的值中。. G/ ]2 C5 M5 R. }6 T. M
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
* J4 ~) u4 j$ @7 k+ m9 x$ eli=[11,22,33,44,55,66,77,88,99,90]! c/ f6 n9 A/ K5 X* Z
dic1={* F( w! c) Y4 G) j) g
'max':[],! H0 \5 v4 Z) Q4 m$ u
'min':[]7 }9 v$ N. S! D
}! p5 F* \7 G6 A, r; K5 O  p% F
for i in li :  n  `; B1 l1 Q9 q
if i <66 :* _, y: [2 {6 {! Y
      dic1['min'].append(i)6 x2 S' m* J# T/ U
else:
* [* T& D* D0 M/ O& G0 W1 t/ T       dic1['max'].append(i)# ?* {& A* t! T- J
print(dic1)  c/ {, f; P$ {; W, L) E6 v
: z+ I+ I3 [. ]# _" Z9 c
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) q% f/ y  ~; I6 W7 ~

Python基础知识汇总

主题推荐