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、写代码: u3 r5 v! F- U+ a5 ~* a( D$ l
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) :
% N# E# W* j4 r" s/ r name = input('name:').strip()
5 j9 v6 z: l2 z/ M( Y5 F pwd = input('pwd：').strip()
/ ]4 J  X5 c9 u5 _$ O7 Q8 R2 a
8 E  \$ ~* A# t/ d if name=='seven' and pwd=='123' :
( H' M( o2 I: L* A) U       print('ok')
/ C0 a* L/ V% S% Y9 n5 E else:
6 L) H& O5 {7 i$ A% j) P       print('error')0 I! q" ]! H; O8 G
      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)  :
- L8 S9 A. m7 Z name = input('name: ')
$ }# e+ ]$ K& Z; ~) f( d' X5 b pwd = input('pwd: ')0 C/ _8 u: o! {: A1 j
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  q9 v; [& I5 I
      print('ok')
8 m# a& _& D% H$ M# C else :# P* \+ V: E4 w
      print('error')/ |6 W' _8 D0 |# x2 H, R; W) d
      count+=111、写代码  [1 o% p1 J. Y: v1 v
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) :; d+ S" x6 z" }  A/ \  `4 }$ p0 A) X
if i %2 != 0 :
8 |1 x% [; L& Q% X       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ A  m6 D8 V5 ^% c9 u if i %2 == 0:
3 F' t+ Y1 p9 ^/ Z; e7 A       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". C( e/ K: g2 I5 g* w+ Z' K
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), L- W% k+ O, V, t9 G
for i in name:
  U% `2 e6 z  r print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain* g* u% K: G0 L" V% C/ s* d+ m
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']" r& R  k, p3 m4 V
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
4 H1 J- o/ i1 L  ^print(li)/ y; B* O$ [7 W* u0 f
['alex', 'eric', 'rain', 'seven']
9 G+ A# T* h$ Y8 l4 X7 `1 [; O9 Ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
2 z/ M: s  p, t( U' J& k  E8 P. Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): S5 z% B$ M; O" f- Z% l
print(li)
. `, x+ o( D+ I& a9 _% te. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']. d( Z2 O+ v2 A7 {" ~, b' C% g8 F  w: |; q
li.pop(1)
2 x+ V& [4 f) Y5 C# qprint(li) ['alex', 'rain']
% ~3 }( U6 ?, ~$ X- ~9 T1 e指名道姓的删除li = ['alex', 'eric', 'rain']7 o9 L  r2 O- M
li.remove('alex'): [. [+ g' t. _* ]
print(li). \" t+ E# O7 G8 v! K% W
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' |; g6 t* J7 r1 h1 E1 J, pprint(li.pop(1))& y6 }" X& B: K; A- |
print(li)
8 E7 |: I- |4 b! N  h
1 V$ e5 _! [3 D6 Oeric- b% [6 q8 v" L1 s' m* v1 D5 L
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']$ \1 S/ a) O+ V9 x  O7 H
del li[1:]/ i& P' Z) T5 x  H
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
! s- H% ?5 f+ P+ B: Gli = ['alex', 'eric', 'rain']. A9 u' n5 C# }/ P0 z
for k,v in enumerate(li,1):
9 S- b. ]  ^6 K6 V# L1 }. h- Q print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" _" K+ M3 e' N) b) @+ ~a. 请输出 “Kelly”
( R0 O5 @  w$ s; p4 ?li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: S/ n& j- ?, \/ ~/ s3 u3 jprint(li[2][1][1])4 F: ^% f1 s) s9 [% w6 a: h8 f; F  ~
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
1 c' B2 s/ [3 W. Y1 ?9 Xli[2][2]='ALL'
: W% `3 Q9 L) t% @$ D% B. }# Sprint(li)
0 m/ W, f# i& T  a2 M6 N0 x6 s24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 K5 y7 ?1 ?# U) C) ^5 Ha. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
! u8 D, [3 ^- D+ ?2 N0 [/ Kprint(len(tu))
+ X. F$ k! `2 _9 x9 ]  b# Bb. 获取元组的第 2 个元素，并输出9 y" i! Z- r1 l) ^6 H' k
print(tu[1])8 o; l5 _/ d4 N' w1 v, q2 R
e. 请使用 for、len、range 输出元组的索引" z7 s  E; H) z- c4 `
for i in range(len(tu)) :
( q) p8 U  U4 v7 u0 [# k) S print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
; U6 n$ k! N. e* w7 Ifor k,v in enumerate(tu,10) :
/ p, K" W, s( |5 j print(k,v); ^3 t% o9 B8 Z( B; x% x7 [) v$ ?
10 alex% X7 ]& l, z% I" U! [7 D, K( P
11 eric$ z$ Z  `0 w- p+ Y
12 rain' V3 i  m& g+ O9 v0 ~% R
9 A6 Q' n' L2 G+ D4 e) C: |4 S' i* p
for k in enumerate(tu,10) :
7 ^4 E9 K/ Y; b4 W; b print(k): w2 V: m: A7 I: t7 v0 k
(10, 'alex')1 z! ]8 {6 C* P* j0 o0 d
(11, 'eric')5 q0 Y) r! R+ Y2 a0 |- g6 P$ Y
(12, 'rain')
. G# W6 \& y( @* O& f, O
" L8 P  `7 K4 k# \& A/ ^2 ?) W' ?2 j2 @3 \8 M* W* r& H8 {
25、有如下变量，请实现要求的功能
7 {" Z' I% Q0 P( ?4 d- L1 A2 btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

6 ?2 `$ l% I" rd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
) E# X: Z3 ]$ r. vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])) `0 ~# X' m+ ~% `
res=tu[1][2]['k2'].append('seven')
+ `) M1 y( J5 x& v& D! M1 F) `9 `9 T9 a5 p4 W  d: {
print(tu)8 T- G# H% A4 s. l9 K: u% N
26、字典
9 _1 M! K/ Y2 j. Hdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:6 M- B" m5 Z/ L( `9 M" J
print(i)b. 请循环输出所有的 value
0 Q. _6 V; K" h1 V* v4 sfor i in dic:
/ G. w* @+ M6 G' I5 o print(dic)2 k$ D4 R& F, X  h) {$ Q
c. 请循环输出所有的 key 和 valuefor i in dic:
! V/ I. p( a' K# y2 o5 f" _print(i,dic)3 w' T. \7 T( p9 z# c" r& K
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典' _5 P: `; U0 r2 A
dic['k4']='v4'
; O1 I3 I: l) hprint(dic)
' z* d; a2 d+ _" x$ ?. `: Be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) Q, @( l' h, d! T' d% Pdic['k1']='alex'
3 J/ l- r4 ]2 d* U. ]1 ]% I( cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 }# ^' D/ t' Y5 {! z- n( Rdic['k3'].append(44)
' l) s. ^8 R! G' q" d2 B! Eprint(dic)9 f% a9 N# r5 Z- ]* t. _, Y
! ~9 u" k: |! T( d+ w) H" F
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, D5 G; ]" g( z" u3 t0 l; u$ pdic['k3'].insert(0,44)
/ G1 W3 G% d. S! V9 R/ Z% Q4 z, r9 |print(dic)
8 E; R4 W+ @, D; W6 A27、转换
* y  M! d. I3 _a. 将字符串 s = "alex" 转换成列表  s = "alex"
( u# H9 x: {! [' t) @; m+ I$ l; }- S8 Z& s
print(list(s))b. 将字符串 s = "alex" 转换成元祖
/ ]% d" \. e: t% x% N, P3 ?9 ^4 Cs = "alex"! m) F% c9 K+ T
print(tuple(s))$ y+ }- G0 l9 V. I& [

' W, Y6 e; O: J' P: A* mb. 将列表 li = ["alex", "seven"] 转换成元组
8 f0 \; I6 K# N! fli = ["alex", "seven"]
, O7 _9 Y3 D% L/ R: C! M# J) I1 [print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表3 K$ @! E1 q# J+ `2 L' _0 R
tu = ('Alex', "seven")
, |2 C- q; v1 I9 i( Jli=list(tu)
3 F( ~6 J2 Y8 j7 t# g; [print(li)  S" q, @+ u# [' j+ P. k2 A

- T% r4 t; j: W/ T/ R( g
7 k) d# C8 A8 j0 ^! _: J6 Fd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- ~& g# a0 a9 s3 f( l3 U
9 `. b' c2 p3 A# T; ~dic={}
' K) Z& [2 M  v; `for k,v in enumerate(li,10) :----li要放在前面，序号放在后面( `: j' U  }4 L* h
dic[k]=v: d9 K; x5 p7 D' h
print(dic)27、转码n = "老男孩"
" k$ d4 `! A' b, v8 e" Va. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩": I' \. t% G! e& t; Q
a=n.encode('utf-8') 5 F1 F8 I& {- p& a) E
print(a)
4 @- q2 m* O2 V2 e; ?4 [b=a.decode('utf-8')3 {  H, [, E# c0 b1 @  I
print(b)! j0 V; ~: Z' F+ P9 t* w
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 n2 ]# s& `  Y) V1 H5 Eprint(a)$ v- [$ C7 A* W
b=a.decode('gbk')0 K4 I2 h3 B- u: _0 q9 k* U
print(b)28、求 1-100 内的所有数的和
count=1
7 L, J( W; A6 J4 o4 m3 t$ zsum=0) F8 q  t% u  l: i/ L! K
for i in range(100) :$ Y- I- g+ `  {6 E8 l% A
sum=sum+count
/ g& p6 r9 [7 d! V: O$ X, ~ count+=1; O! c8 y" q% \) V; b
print(sum)
& l) s9 G9 p' i- F: o. I# N  e' w: B# ?9 c" v, V
count=1
# t. w! {5 U- t5 qsum=0/ _5 E) w0 V1 O# I. H8 ~
while count<=100 :& x. G! y+ }  T* Q5 c
sum+=count8 V" N) ^  C9 z: Z4 y
count+=1
# ~6 ]; n5 t6 R1 xprint(sum)29、元素分类
3 d- c8 A  ^# c5 f有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，7 R% }: {0 d' z6 s" Y5 X1 U7 W
将小于 66 的值保存至第二个 key 的值中。
6 b  E" p9 g9 D; \& d, n即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}; g8 ^- Z+ Z$ {- y
li=[11,22,33,44,55,66,77,88,99,90]
8 F9 C' U# `. A- s1 Udic1={
! ?6 V& t/ L# V8 d) y 'max':[],; y5 s, N3 Z% ]( D% ~
'min':[]
) g9 p) P2 o0 a0 U# T" ^% I}
; K' `* s( U* V5 y. j, afor i in li :/ {  Q5 m3 ^6 ]5 k0 z
if i <66 :. f# t; M" ]1 }# l" j( Q
      dic1['min'].append(i)
* _* T) M% i: n5 Y6 H$ V. Y else:
7 g9 y% ~9 ]) b/ \  R, ^       dic1['max'].append(i)+ A) {& {3 u3 e  ?* F, V* E
print(dic1)
3 f8 R! l2 |: f, d% I. t
+ ~4 K% d, U' A! M7 V7 j---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 t4 H' W8 o% m& i5 G5 J6 _. {9 A

Python基础知识汇总

主题推荐