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、写代码
, v. q0 _) d+ ja.实现用户输入用户名和密码，当用户名为 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) :5 r7 z; F( ]! o
name = input('name:').strip()
& r, F0 n% z9 N% p4 a) h pwd = input('pwd：').strip()
1 e- d; h" ?" x! a
, P6 X' o) }3 R' K if name=='seven' and pwd=='123' :
' |; j+ C0 ?2 U; S& ]3 H3 m% K& ]       print('ok')
6 M1 e. u- {; M2 l else:8 t# i9 b6 u! x8 x  n7 D% B
      print('error')$ f9 ?3 T- }. V& s
      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)  :
5 u6 m! [: e! I& f name = input('name: ')
2 O/ Y+ q  |) T5 _& l: K# T* ] pwd = input('pwd: ')
; j( g9 E* C  k; J  r! E8 E$ q, T if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':5 }, j2 c: H+ C$ Q, E
      print('ok')
- \( ?9 S$ l0 q$ |9 u: n. u else :! y  v; }8 ^% C# K
      print('error')
& G- Y$ F: B6 K( O" N4 X$ s       count+=111、写代码3 d2 J* x8 t2 Z
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) :
9 L& q! N, i" k& b! Z" y% R) t% p* F if i %2 != 0 :
' s9 T' S: [  @1 M       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :3 B- U+ H/ h. W# H2 f6 N7 F
if i %2 == 0:
$ R& O3 @9 `! O  m; N; r0 S% n       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"% W+ A" Y% N: p- R$ ^8 {
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)
: `" P: f( y' gfor i in name:# x" _: j1 T+ S! D
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
% S# N; R6 K7 c( i8 C# {  O22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']# m1 }! v0 Y* @
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    % R( l6 f; O+ y. c
print(li)( b! F2 q9 x+ v% V- \5 b5 p
['alex', 'eric', 'rain', 'seven']
: c" s2 e3 c5 Z' ^8 Ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
6 v" x+ Q4 ^; I8 W* hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')  ~% x2 ]7 ^7 R) T& F0 V
print(li)
* }3 n! ]1 |2 H$ We. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain'], j# s( e# E8 m1 b) F
li.pop(1)
( z# B$ ?9 d3 x' j* h/ k3 iprint(li) ['alex', 'rain']
3 O+ x. g) @% V) Q2 {) x指名道姓的删除li = ['alex', 'eric', 'rain'], r# r# p! T* p1 M# S: ^! Q. _$ H. g
li.remove('alex'); @- D  i: d# s! r; n
print(li)
) F+ {+ _! i& x# Q' k7 hf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']: P0 m4 k9 ~7 J! Z
print(li.pop(1))
2 q4 E3 C3 S9 ?8 qprint(li)- v) h% R& o. {, x1 z, P  x
$ k: R8 v  c- D- t
eric
& q9 \. d, T$ \7 G7 g; P* S['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: O2 K9 \! I$ _* {9 u/ Adel li[1:]# V% H3 M- U! G8 ^) Y5 `' ]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& f# \( y" H% B. X# u7 m' v0 Xli = ['alex', 'eric', 'rain']& m2 L3 o6 ~/ q2 o
for k,v in enumerate(li,1):8 _* }' c  f7 H+ s$ a
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ `% p0 H2 g3 g" W2 e$ a4 v! d3 d
a. 请输出 “Kelly”5 k( \- V- k% v, A* A& S
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]) ~: N. w, r/ v# s5 s& G
print(li[2][1][1])
6 p7 ?2 g" U' Ab. 请使用索引找到 'all' 元素并将其修改为 “ALL”; L5 @9 f* ~) m5 c6 M; g$ x+ X& U
li[2][2]='ALL'4 `7 ^; O9 z; N- s5 x
print(li)
/ K0 Z2 h' r- ]5 m8 |, a24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')$ V% m7 f  s. b& a
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
5 ]& Z( ~5 `- C% Aprint(len(tu))
& {0 \: b9 B0 fb. 获取元组的第 2 个元素，并输出
) v3 }( N: z' N" t8 B* c; tprint(tu[1])
" J- x+ Z9 t- E2 ye. 请使用 for、len、range 输出元组的索引4 m3 z* H9 J5 d, f3 P- `' G
for i in range(len(tu)) :4 s1 i" k" M: r6 B7 d0 x! r. v
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
! Z1 M+ P# K9 L* c0 o, jfor k,v in enumerate(tu,10) :
& ^) [, \- s& Z: T8 ~; u print(k,v)
* C& r% K4 B5 u+ ~10 alex
5 m: H8 Y1 @# x1 V2 J& B  X: X11 eric# z, B. i+ v% g( m/ C# ^- g; i* p
12 rain
% p7 n& G/ d: t4 t1 ~( C' q0 Z0 u- V
, x) I0 n' S  S( y2 O/ j9 c) r+ sfor k in enumerate(tu,10) :( o8 ^. S7 o- K3 f2 I$ ]3 N0 r
print(k)" b! {, T( z6 F3 Q4 W7 l( C
(10, 'alex')
1 \/ C2 A: X% F) G" t4 Y7 `+ a+ G$ o8 [(11, 'eric'), u0 s/ p' R8 y7 s
(12, 'rain')6 {0 ~; ~! O, G" o2 q

9 O- d6 k1 h: ~6 Z9 l* B, c$ C4 w
5 D* P% s& y9 j' C8 b25、有如下变量，请实现要求的功能
2 e  O4 |# Z) E- \5 e2 Ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  Z4 o2 P0 w& ]. @# Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
6 \- w' h0 ]: E" H7 s* Rres=tu[1][2]['k2'].append('seven')
6 \( Y2 G$ y1 _$ h- C  ]9 K7 B' o" z
7 X; w3 m) L0 }' ]2 D% Lprint(tu)
( ~/ H. ?& }( M2 ?! |  x26、字典. i: K8 a7 H8 `
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:7 i- ]$ {8 P: h2 w% y/ V0 U; C. a5 b# e
print(i)b. 请循环输出所有的 value
2 o/ c) L# W7 ~! p* m( Ffor i in dic:& F+ @7 A$ R; |7 e
print(dic)+ f" ~: O2 Y/ J7 F
c. 请循环输出所有的 key 和 valuefor i in dic:
: u) H4 h, j; V# F/ c' e& \print(i,dic): j: w9 U# Z  M( [& v! I
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# Z  S7 t' O) Q; G* a$ a" F8 q
dic['k4']='v4'0 h- K  h! ?  A/ O" m5 _
print(dic)
! S5 q4 A/ ^7 J# U4 `1 ^7 We. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
6 a6 a2 Z4 K) mdic['k1']='alex'  P2 J3 q' `: q1 w6 H& K0 C. D& y
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典; F' `) s; ^3 ]& L4 q. ?  C6 y5 r
dic['k3'].append(44): P4 w( S% m7 R. s1 n
print(dic)
8 V, @" [% i1 j" p+ g6 g6 z! M) c9 i! J5 A, `, V! q7 x
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
  f2 h0 m! M3 r6 B* a4 A) U3 R/ B5 ndic['k3'].insert(0,44)
# ~" h7 P, i7 H/ @* r" ~# y& Y) pprint(dic)$ s8 P8 b2 n! o
27、转换
2 l$ s2 _9 e" h4 U! aa. 将字符串 s = "alex" 转换成列表  s = "alex", p7 a, R, ]- Z, `1 Z

) r  h# x7 G: X0 S2 _print(list(s))b. 将字符串 s = "alex" 转换成元祖: x( @$ C$ l7 y) v2 A
s = "alex"
/ {6 L4 Z# w+ \6 z6 d: Dprint(tuple(s))
8 c' J1 a' w" H  C$ {, T1 v) z& U" ]% f
b. 将列表 li = ["alex", "seven"] 转换成元组
' c( z: [% Y) B; Pli = ["alex", "seven"]5 d& J; p' o# v. j; L
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
# u" k" J5 ]3 s* l1 z6 b6 }: Wtu = ('Alex', "seven"). U, X9 H7 s$ g1 `# y* ]
li=list(tu)
/ e9 D, R7 A* `8 Y4 sprint(li)
: L; x+ w. u5 V/ F# ]9 k4 Q0 `1 q2 C& J* q9 f7 y7 U

7 j% }( [- g* F) k* [6 |" Hd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增+ X+ P. @1 e7 @& o8 x0 J2 `
) c6 S( m' b. {0 J3 I
dic={}
& X1 W! F( M' s5 \1 m( k  ~' kfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) Y; ?2 R8 X, Z& E! ? dic[k]=v; m  D1 U% y, a& z& N8 t
print(dic)27、转码n = "老男孩"
* b. I2 p4 h; X; }a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
0 T( q, _) X7 e$ o5 xa=n.encode('utf-8')
$ B- l/ N% n5 ?" jprint(a)
# i6 x  q9 `( t$ w/ f0 {* Ob=a.decode('utf-8')
% |) b" c+ l& U- I1 y2 }; s( K1 \print(b)/ q0 l9 D- p; y/ G5 b
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 A3 }0 }. l* h9 h+ \
print(a)  `9 h! w/ M' a$ e
b=a.decode('gbk')
+ G# x( b; \4 A9 z! X4 O- |print(b)28、求 1-100 内的所有数的和
3 |; ]7 W0 s. Y* O: J" P- ~8 |7 p0 Wcount=1: N0 A% B! L! f/ }9 s# ?
sum=0, X* d6 |0 w, f# F2 \$ m
for i in range(100) :/ x+ c) y& c/ G9 w+ E
sum=sum+count5 O8 a1 l2 T  s, c
count+=1
4 B, e+ q; z% [print(sum)- X( Y9 j3 R; u3 I. ~

: p( Q# [' L) S8 p7 T  Z7 v" ~count=1
! T7 w$ R0 n: [; [4 Z* Ksum=0
+ {8 O9 y& C3 bwhile count<=100 :
; i0 f6 G0 e. S" H9 a sum+=count" T* Y! I5 |+ `0 m( v7 ]6 ^0 b. Q4 \
count+=1
. i5 x9 g& v, D) z7 z' Gprint(sum)29、元素分类
8 Z6 ^  A! L/ q( N有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 ~) F: q/ [0 [
将小于 66 的值保存至第二个 key 的值中。
, y* o, n( u/ X+ I9 B, x8 ~/ O即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
$ s! {2 o% L" k3 h4 qli=[11,22,33,44,55,66,77,88,99,90]5 f2 e, X' I) A6 N% q! T1 O0 `
dic1={
* x7 ?$ P4 n: f) c 'max':[],
4 C  C4 t0 Q6 b0 } 'min':[]
3 w7 K. M9 M. V( X1 G}! ~1 J: `! U! c: m  J% G
for i in li :
8 l/ X1 a/ h, H$ D/ G5 p if i <66 :
5 L8 h! t; S  e& u- F& b       dic1['min'].append(i)
3 L/ h( |# N$ ? else:
" v1 F0 z& Y3 U- |* c. |  S       dic1['max'].append(i)
: x* w% a0 k# Vprint(dic1)$ Z  J1 n( A' K. F! I& Q
, w7 o) P& ?% m
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}9 f/ a0 r% T" ^0 W. w5 j( i

Python基础知识汇总

主题推荐