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、写代码* |/ I" l! L# m! d/ s
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) :* |9 g) C% x9 \% u1 c) n
name = input('name:').strip()- H) j/ J0 w8 g5 k  U
pwd = input('pwd：').strip(), ~8 h' h/ X1 h" L# b9 W

/ j' E  U2 O- C+ e1 |  J( N0 } if name=='seven' and pwd=='123' :( c* o1 i. j) v/ m2 F4 K  d1 n
      print('ok')
8 s7 d6 Y$ s# {6 h; l else:9 H  F* K: U2 w) s& _
      print('error')& w1 [9 n' C; B- i
      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)  :
$ H( @0 P. O3 @2 s* ?1 ^/ D& N name = input('name: ')
6 ?9 B" c/ i2 x. z! [; o1 k' Q pwd = input('pwd: ')
* D( A0 V% z0 l* J2 n% q0 L if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
4 u, O* U4 c0 E; t7 r       print('ok')
; }* K( _* b7 f else :/ }1 ], J' G. @5 k; {3 P
      print('error')
. D$ U$ K* O; b       count+=111、写代码
. H6 m; R! F2 F5 k$ y5 Ha. 使用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) :
$ W2 C0 I: I4 ]1 d if i %2 != 0 :! N) ^6 R0 e' |9 k5 z% ]
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
+ x" ?* T$ w- x; G" K if i %2 == 0:: ]" ~7 b2 i* m( L& G6 L$ Y
      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"
) F6 s& p4 G: @1 G$ j/ X5 Ga. 移除 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)1 X+ u! |4 t% R5 c1 `5 S! Q
for i in name:- ~) n6 d" \& O. ?, u  Q) R
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
: L2 i. a0 ~3 q" g8 l22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
; X; K8 B0 d' z* a4 Cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    - o$ U- f5 c' q* N8 K) G0 F& w
print(li)
8 s" O# g. P2 d5 B  x  o) u ['alex', 'eric', 'rain', 'seven']- B. k5 @# j; l  Z. S$ ~( J! w
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')- n# _7 w  }# z# d  E
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')7 P. S4 @  G3 U! i/ M
print(li)  X+ L$ w, V* u. M
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 t3 g/ P) W) u4 H+ W
li.pop(1)8 {2 Q' g: V3 O0 Z; V
print(li) ['alex', 'rain']8 W# g0 Y+ X& u, k
指名道姓的删除li = ['alex', 'eric', 'rain']( L/ f/ |; G( K  X9 E& T, a, V
li.remove('alex')
( n( Z, J8 a, k7 kprint(li)* M9 s! t1 n; K, Z! S+ o; l
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
1 n7 F' F8 K& S' w* o: gprint(li.pop(1))
, |- t$ m- [9 r  d6 E) p) ~print(li)1 n9 j6 n! {% ?' X
( k- C9 x  Z/ Q, p6 W
eric: L: j; D# E8 ~" r* ]0 `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
- o9 _7 y2 ]! W5 s* t# Kdel li[1:]
' N& S0 C/ L; K) Lprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
8 x* k5 i8 R' t" D4 \" U7 ~' ?5 Bli = ['alex', 'eric', 'rain']- G2 [" u7 o0 Q1 X* x
for k,v in enumerate(li,1):$ Q' k* w7 Z$ U4 P$ ]
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 k/ i2 w* _% a. Fa. 请输出 “Kelly”) h; n! M) K; U2 |
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# I6 K, k. S3 i/ }& v+ Uprint(li[2][1][1])
6 n& E. P7 _$ m6 W* A  Fb. 请使用索引找到 'all' 元素并将其修改为 “ALL”& y* [& T5 z, Y0 I1 Y, \6 ~
li[2][2]='ALL'- T. D* C; C7 D& t- S2 k/ H$ a
print(li); c/ r# J' C. x+ K- r
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')  F3 o+ E% D# J; h  |: ~# X# a3 S
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ R% r7 S8 ]- {7 @% H; r8 i& Bprint(len(tu))% Y: v$ ^4 F% L4 C5 o6 y/ S# b5 r
b. 获取元组的第 2 个元素，并输出1 D' S: c6 C# V7 N
print(tu[1])5 `/ O3 N; ~5 ^3 \
e. 请使用 for、len、range 输出元组的索引& O( F; s, U8 ]8 _$ W) p- i
for i in range(len(tu)) :4 ?, r# v5 `& a- ^' G# c# |6 [+ V
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, ~" U0 e4 E$ {5 o; x! @for k,v in enumerate(tu,10) :
3 G( @0 D) _6 C# C0 P' q, c) p- s( S print(k,v). l% S$ _+ M5 Z9 o3 c; e) C# c! S
10 alex5 C) u. t( M9 m7 u
11 eric
  N0 n: L/ h# v5 _  ~+ f1 \7 m12 rain
  G/ y6 [( C$ b$ _4 i$ X& p$ v
. @+ e/ h+ w8 _" u' y# K; Efor k in enumerate(tu,10) :
. i6 n% C/ m1 A2 W+ f4 I# y print(k)8 [! n- N" j1 m% Z; E
(10, 'alex')0 p: q- z5 j7 _2 m( T& I
(11, 'eric')
% M6 t0 Q) [5 F7 n+ T(12, 'rain')9 K9 ?8 r2 ~/ v2 A& L& Q
" \, J( I. Q* ]' I* G* I3 N  i
8 w9 ]+ a0 n1 `  H! F* D. r% ^) b
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

7 g& q5 o5 \8 P# ?9 ~d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 F& r- f5 |3 |tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])' J" Y4 j7 j7 {# Z, n
res=tu[1][2]['k2'].append('seven')" @) [- H* z: k7 u6 T
* W2 G7 Q7 C4 `$ |3 r& \0 P
print(tu)
. c2 u1 |3 }; t- g# [9 I$ Z! i26、字典
" Z5 _5 o3 J/ m4 C* z' xdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( G5 j0 y8 m# I print(i)b. 请循环输出所有的 value& q% y* x( Y6 H% l3 p/ ]
for i in dic:
" M" F" q. X- M; w: ? print(dic)) y7 z% _5 k1 h7 t4 ^, s2 T# v# B
c. 请循环输出所有的 key 和 valuefor i in dic:% T/ C* I+ I" k0 z4 n  E
print(i,dic)' ?7 {7 V0 F  s, x3 t* h4 r/ r, h
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
2 w& E% K8 o+ D, z/ ydic['k4']='v4'& W% c4 M1 |  N, k8 M1 h0 {
print(dic)
  P; S6 J/ z2 T+ ]; Je. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( B6 S, b" e8 M5 P- l+ @dic['k1']='alex'" O$ M4 ]7 @% I( Q8 D7 m
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 t: l% @2 E- H8 I2 [% l& {dic['k3'].append(44): a/ k7 x1 P3 A& y2 N
print(dic)& U  n  o* l5 C$ ^

% }$ o9 U/ W, k7 Q) bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 I6 k9 [& X' R: e( T
dic['k3'].insert(0,44)
& T+ E1 \* s  k. ^' b7 H# k' qprint(dic)/ i1 z) n3 w- a% p
27、转换
- i3 S  g5 `2 H5 a: O) b7 ea. 将字符串 s = "alex" 转换成列表  s = "alex"
; {/ Y  S- k/ U! b6 r/ G; p
$ z9 e+ R$ t* b. p2 Cprint(list(s))b. 将字符串 s = "alex" 转换成元祖
8 i) \7 p. b1 o: a2 zs = "alex"2 e9 Z- ?  j; M: l& m
print(tuple(s))
; i% i' z7 e: G8 X. ^  I
: ~* R/ |1 z5 |# U! eb. 将列表 li = ["alex", "seven"] 转换成元组
# l' s- m9 M" X5 _' @' Zli = ["alex", "seven"]
; G: q; {4 m$ [! X2 O* Mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表5 i) J  P! M, Y8 k( @
tu = ('Alex', "seven")
! U& C4 N* P2 cli=list(tu)
print(li)
- T' \2 d7 V0 k$ g+ m$ v7 L
+ V. [& L  L4 @+ i( E( \) A7 S1 ]2 f) x% w/ L
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增, [: O" [! |4 t8 D2 e' L0 b

" h! [( W& D1 Q0 D# n. Xdic={}. \7 O! j" g: Q# \
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 ?! E, N# p- J' `6 i dic[k]=v# c! F1 H/ H# I
print(dic)27、转码n = "老男孩"
9 u8 e& r7 `# k3 A2 p. `; x, ua. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# [. i4 I* d) aa=n.encode('utf-8') , V) o, j7 A# e6 {4 Z
print(a)
/ a  X- s; U! h! n, o+ G: v' gb=a.decode('utf-8')
/ F5 v* ^& O' @& \+ {) C& [/ ~print(b)! t% S, D% m- H! X) I
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')& \- I% c( i( e! w
print(a)
! @; N# p' ~( z) @( `1 ub=a.decode('gbk')
0 h  Q) Z2 [% ?  O. H8 Tprint(b)28、求 1-100 内的所有数的和
' J' N3 `0 A; E) n. u  q& j5 jcount=1
3 N% w9 u' a3 j) j  _0 Y. }5 Fsum=08 L* H4 t) E' u. i
for i in range(100) :
& M! e; d4 b& s) m/ R( }7 ^ sum=sum+count
. a5 F& ?9 K) Q8 D+ m+ n count+=1- r4 I% t# ?  b4 u( A
print(sum)2 A! U8 l& A/ h/ G" z/ q

# h! ^/ ^1 Z3 T+ u% hcount=1! K/ `, y2 `' y) t1 l
sum=0
& |) K, v- ]' T5 mwhile count<=100 :: A" o* T; {, ]
sum+=count
8 ]6 [( ^# `5 Q3 t, K count+=1+ A% v4 A  N' Y8 V! b
print(sum)29、元素分类
# H" ?! ?: n' ^$ K7 M有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，9 m! d1 b# v/ n# \% E* T
将小于 66 的值保存至第二个 key 的值中。
4 Q$ J7 y2 K& s( D1 r4 A# o即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}9 N- @" M( w8 [2 E& i6 E+ b" [: I
li=[11,22,33,44,55,66,77,88,99,90]* M# A( P7 A, g) U+ P
dic1={2 E' P) z5 O. C6 f
'max':[],8 E* m0 p' L' ?5 p
'min':[]
1 B! q0 n& e; R}
8 A% F$ k" n9 wfor i in li :6 m3 j9 ?) f3 Q$ {- N8 z/ ?
if i <66 :
9 u0 T0 ~* ?# x# ?       dic1['min'].append(i)
: ]8 ^4 e: n" U4 E  P* c9 d else:
) @0 B* b8 ]  h2 L1 d6 h: g       dic1['max'].append(i)
/ G; d  w! G$ C; l3 {* h7 Nprint(dic1)
- I% t, w. C: O  Y" m( ]4 q: O* j. h: G, d' P
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
& Y" B; d2 m% p. X

Python基础知识汇总

主题推荐