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、写代码" b) X  [$ k- @( o& j& X* {' Z. F
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) :% P. V# Y* [6 G9 p5 u6 s8 j
name = input('name:').strip()' ]7 d4 y1 q9 L' ?4 J
pwd = input('pwd：').strip()/ d9 E, I& Y5 g* ?9 q
) s8 j- Q3 m% D) `  o
if name=='seven' and pwd=='123' :
% e, x9 b& [7 J+ U       print('ok')) W/ l3 n( h/ `
else:8 M* x4 K# H" Q; w8 o" ~; p) o
      print('error')
) m5 q6 S( `& r" X       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)  :( o- _, @: C6 A$ y' |- Q& e$ Q) m
name = input('name: ')
+ c8 l' m) b2 Q* S9 P  i pwd = input('pwd: ')
/ h+ z% B) h- c$ S) C9 o if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':5 d0 V$ h/ g: u- r' }
      print('ok')
" P4 k( Y! h7 ]' P' L else :$ \) U5 E4 O- ~# k! z
      print('error')
7 X/ X/ V9 B9 w' F2 L) [       count+=111、写代码
. s1 i4 B2 ~# o4 C' H, o# [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) :
) h0 v" F# b* _, V6 B5 B if i %2 != 0 :! N* z$ Y6 t. l
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :( ?  B/ c( c% k2 w! ?) r
if i %2 == 0:
* |& L3 ]: `9 E       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"
& B# F3 k( y& N8 S. f# Ya. 移除 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)- x3 I. Z+ `* S$ d
for i in name:6 e8 ^( @2 g8 Y. \
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain' l5 ~1 Y9 _0 n3 [0 O
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% c. k5 ~5 d% \) p7 tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    / p0 \: R! K3 n8 c0 O9 @) ]
print(li). h5 j8 D% o2 j7 _2 i4 u, v
['alex', 'eric', 'rain', 'seven']2 l; F% ]2 I  w5 p0 H& j: E
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')1 N1 W, Z+ M% M4 Z% u9 M7 G
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
+ _0 C$ k+ w, Dprint(li)  {  f0 }6 e) _) v& `' p# ?8 p
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
. x; M1 a& p  [) g; V& {li.pop(1)
7 j* W- ~" z: I# F: ]print(li) ['alex', 'rain']( u1 I8 U, C0 \- ]
指名道姓的删除li = ['alex', 'eric', 'rain']
5 H8 E. t' \1 M& ?li.remove('alex')1 M) z" @; [. T, y* i. w* k& M
print(li)
7 K3 H! K0 W* ^8 Zf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']  p, u% l' p, G/ U
print(li.pop(1))) b* U, j# S. L" v6 o
print(li), r( V0 M) T! n+ }0 `3 r
( J0 m* r6 A8 g$ m- I! A" P# G6 i
eric" b, P1 b% W" Y# N1 v. F( |2 T
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']/ m3 ^& J9 Z5 {+ \- G9 F4 \% r
del li[1:]
$ f/ \% R2 w5 _( Z# Z: v' Tprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)& W+ J9 i/ r1 w  W$ C7 |3 f+ s
li = ['alex', 'eric', 'rain']
* t" Z7 ]: q& ^, |for k,v in enumerate(li,1):- {' }+ B+ C" h7 v
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 |8 ]& _& S% G- ~! ?
a. 请输出 “Kelly”( z2 U, T( G* x, T2 l) X
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% ^6 q3 `2 x4 E1 V, T+ {
print(li[2][1][1])
1 g. t9 P4 g: p0 W" [; {b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  i0 c' I# ]3 M4 t+ x- V$ g. uli[2][2]='ALL'
" O4 U  ~% `; a8 V* F; xprint(li)
( F  n  Y; E: \# W4 ]( b6 E, t0 C24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
: {" n$ P! c# V4 e9 b$ Ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')3 g0 g5 i$ j% C
print(len(tu))% o6 i( u/ }1 r6 i2 m- A
b. 获取元组的第 2 个元素，并输出6 u# H! d' r& l
print(tu[1])# n4 R5 |7 H( X, C
e. 请使用 for、len、range 输出元组的索引
7 p3 x3 @1 v' Q& W3 L9 `" cfor i in range(len(tu)) :
0 z  o. ~6 b# N+ I( A; @ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
  J3 a" D& `! u0 v# r( ~for k,v in enumerate(tu,10) :# j6 @  Y- f, Q) u  r% ^" \' O
print(k,v)
1 K9 p) x, o! H/ F10 alex
, r& L% k) F! O11 eric$ v" z- `: n5 e( N+ z, U( ~
12 rain
0 J3 z" B6 Q3 B" a* w- Y% P
+ Q( x0 @: Z6 R/ @, `. f2 Kfor k in enumerate(tu,10) :
6 P3 R& K) a8 N* F. T, V1 H5 B7 i print(k)! n0 [. y$ M( ^5 V
(10, 'alex')
2 c8 p  ?1 P4 F7 g! c# L(11, 'eric')+ c' l- E& S( K- N* H7 B" ]0 q0 U
(12, 'rain')' c1 d; F2 {' @" G% A2 Q

( [. |6 f3 O" `
: `! O* A- d$ y7 ]( r: Q% v25、有如下变量，请实现要求的功能
& g; X1 Q$ Z7 K" }# K" d( Ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; l2 v* F4 _0 W! C9 F+ S8 Y& hd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
' c6 X1 s- q. L' ^5 Qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])" N3 b/ [" ^$ C
res=tu[1][2]['k2'].append('seven')
% ]8 c/ E/ y6 x% ?
& S, }7 ^3 K* b  D' ~print(tu)- L3 x' q' R: m- m( ~/ P0 f6 G
26、字典/ n1 i- B6 q7 K3 w1 ]" A
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
0 `- N8 j3 U, H/ H print(i)b. 请循环输出所有的 value
4 M2 j2 o) J7 z5 q& q! mfor i in dic:7 k/ {$ L2 [' n- {
print(dic); e( V: j5 y  P9 I: a  J4 P
c. 请循环输出所有的 key 和 valuefor i in dic:9 W; Z: j' }& I# L1 u. B
print(i,dic)
% {& m, Y! O7 |6 y3 P. C3 nd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
$ B- s% S( L$ {! udic['k4']='v4'
! @* H+ k" l6 H4 g6 I# `$ T' mprint(dic)
3 w( Z( M/ y! _. Le. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典' x4 Q3 u1 d% F* b: m
dic['k1']='alex'1 n) S% {3 l% v5 X9 U
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. s# @2 H! ]. X9 }% G7 k- k4 H& Idic['k3'].append(44)( A5 s/ P9 L9 `" x+ w4 \
print(dic)
0 K, E$ {% u3 }  U5 f8 t: G
* R: _  K- B; u( ig. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 O% d, G8 p! R. ~( |- n2 w' tdic['k3'].insert(0,44)
9 T, H# c9 f7 a! N) w9 eprint(dic)
' t( @3 `7 j5 w6 {  H) ~27、转换# O& p. G' [) I. s- E, R# }
a. 将字符串 s = "alex" 转换成列表  s = "alex"
3 k% B0 `- U* Y$ N7 l* r8 Z) U- G" w
print(list(s))b. 将字符串 s = "alex" 转换成元祖2 S5 O  k% h5 [) h( X  l) |1 |
s = "alex"% a" B0 P) K* X" P1 q! Z" G& d
print(tuple(s))$ E+ b. e: y; J' O9 s8 W+ k6 j" v5 u
4 L1 n8 A/ T4 Z7 L1 O
b. 将列表 li = ["alex", "seven"] 转换成元组3 N& z3 q4 L8 s; _2 f
li = ["alex", "seven"]" m. @$ e( z" I2 u" N$ P- h! m" k' Q
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
: ]) j, |) E! o& E1 O3 {  e8 {+ Stu = ('Alex', "seven")5 ]9 H& A! x$ @# x' o/ t/ r8 Y3 V
li=list(tu)$ U0 n% L' r; G( \/ @
print(li)* `- Y* N) }+ ^. Q; A1 h, H7 w3 I
$ D* S1 D3 H( |6 C5 j" n: Q

8 O6 g& Y! I7 a  r: Id. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 s9 b9 e* z, d: T3 h4 B! O% d8 ~5 K. H) K1 H1 A1 d8 p* `
dic={}( O) [# @- m$ _: S" r3 \$ a) R
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面3 B9 \2 \$ U! l1 w1 {# |4 X
dic[k]=v! j) U2 J/ r# z9 l0 a/ x
print(dic)27、转码n = "老男孩"
- N' L* `/ N9 M, ~9 s. a' la. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"- N7 t: [- M9 w3 G. L
a=n.encode('utf-8')
! |6 _% y3 \: Y4 }6 W" qprint(a)
8 ?) W% m9 M$ V0 m# vb=a.decode('utf-8')0 s1 s' z4 i+ f0 }: ]# G
print(b)% J$ @  e' H3 E' X, ^$ @+ }6 B7 T
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
" J7 Z& D/ _  P7 i2 }3 ^5 ]2 Jprint(a)
. F$ e5 s! I! W. z9 \2 Gb=a.decode('gbk')/ y1 `' w, G* k
print(b)28、求 1-100 内的所有数的和
! c8 F) r! {( C5 Kcount=1
: h; x- O8 i* ]# U; ?3 z1 \! osum=0
* ^# Z: [7 W8 m; f, g- mfor i in range(100) :
! \$ H; `& j" Y$ k* \7 J sum=sum+count6 Q6 N+ \  c8 G& M; j+ `
count+=1
( x% C8 Q& ]# g& b6 v  y5 S. sprint(sum)
2 C7 Z/ ~/ ]+ T9 p1 U9 I2 y7 ]3 j/ T% H! A
count=1
# b2 B' e  [0 s# Rsum=0* u9 A' ]: G5 ^/ [9 X( c3 _
while count<=100 :! T/ R) t$ d6 h' D8 D& h
sum+=count6 C  J0 `3 y/ s: a; M
count+=1& U% B. y6 }$ `4 e
print(sum)29、元素分类" Y( ]! r; w% v+ Y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
9 P9 G3 n3 M3 E将小于 66 的值保存至第二个 key 的值中。
" D4 w& E: F2 `, K- Z: w, F; l% a即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 @: I! C5 T& G4 uli=[11,22,33,44,55,66,77,88,99,90]' a8 z+ {, U8 i1 w2 r( I
dic1={6 c2 d4 U/ h5 K; ~
'max':[],, F6 e, M5 F: Y! m5 X  T! L
'min':[]" p- c  K; ^2 G: i/ b! y- m7 q* e
}0 _. ^# q. R( q( G5 o/ \
for i in li :1 v, e" F7 E5 I4 B- ^
if i <66 :6 |( B9 D1 n4 N" }# S: f% p* C. f
      dic1['min'].append(i)+ x  q9 X3 P3 u' i4 U. R+ {
else:
3 v& {! _. l; m: C* e1 `1 a       dic1['max'].append(i)5 v0 r* q: l. k/ ~* H8 k
print(dic1)
# r7 S) D1 q, V  _7 |
+ K  ?; z5 C( I) j% K, `---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}* m# }% z) L% r" J

Python基础知识汇总

主题推荐