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、写代码( |7 _: o9 }- z% q
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) :2 L: P% W% g6 t. C: J" x! n# T7 }
name = input('name:').strip()9 @8 h- C  C% l8 K% y9 a5 |: L6 Q
pwd = input('pwd：').strip()
# T1 A) c' U8 X! F, N+ m5 D" J5 `$ \" h
if name=='seven' and pwd=='123' :3 Q* F/ ~" k6 O7 p* x/ X
      print('ok')
% ^8 v9 Q7 c) k6 A8 m$ w/ f& K: j: d* K else:( b1 P( V# `) I
      print('error')( J$ m; G" {5 w8 K+ }
      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$ P- {6 ~, f$ d5 Q name = input('name: ')
6 j& H% c9 D: N2 X1 Z3 z pwd = input('pwd: ')* b# }6 M) Y/ ~/ c* h: t3 o/ P
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  h+ |( {  m2 a       print('ok')2 m7 F5 q2 @" o' n8 ^& M% h( X
else :' U4 R9 g1 Y# n2 x7 ^* }, L. a
      print('error')
  P* ?4 ?. {8 L8 T0 R       count+=111、写代码
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) :( a$ ~9 B5 v+ Y
if i %2 != 0 :
( I2 N7 W1 l; S" C) K6 J# u       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
7 k  j+ Q7 r* L1 p8 C* z/ \( `- d if i %2 == 0:; _! w3 d4 a: x) h9 G6 y$ o
      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"
& K. Y; I4 J" |) W& D" ra. 移除 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)
$ a5 M) d* t0 B( G0 q* ?% afor i in name:
9 ?, h; n, D+ \& Y  t9 B print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
. U) I7 m+ t: v3 l9 P6 S( O22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- L" w- V/ O# `4 x
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
- Q6 f" E7 Z% s* T8 rprint(li)% o/ h% n0 c5 Y% z# C8 a: t
['alex', 'eric', 'rain', 'seven']0 `1 Z, K7 t7 T+ `
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')- y* f2 t5 f9 U' j* a/ ]+ ^
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')5 J, }/ j' |0 Z' E
print(li)
5 o" S9 q9 t5 `2 E" E; @, Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; U! R  _; f7 K0 F5 |& zli.pop(1)% k( t5 }' z) l1 E# y2 b& Q
print(li) ['alex', 'rain']9 f, V, A3 r/ V8 i! E+ t* v6 H" u
指名道姓的删除li = ['alex', 'eric', 'rain']
% J6 [0 a$ f& L) Y$ Xli.remove('alex')2 l' B& E5 R% @1 l+ m
print(li)
2 m) h0 _) H' m" q8 Gf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' f0 s% Y; y8 b& a) ^5 Rprint(li.pop(1))
2 f+ P# Z4 h+ ^# D+ wprint(li), c/ L+ {4 y2 e) x# l0 h  a

5 p. t0 I+ @- w  V& Y3 Seric/ w) f+ D6 U& l) b* Y% z
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 n& p4 A8 \/ Vdel li[1:]
% r9 L) T* M, M3 d* I+ Pprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)& Q' M; X  r! Q+ t6 t& S
li = ['alex', 'eric', 'rain']
  x' \3 t0 ^! j$ u& x  wfor k,v in enumerate(li,1):  E) a& o' g/ l7 U: v$ B
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 P  d8 c4 ?+ b5 s; y6 X3 u  ~' Ga. 请输出 “Kelly”
9 f) a4 A" V: R$ H8 c% }li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& S: n8 U8 J6 T4 F. d3 C( d9 ]
print(li[2][1][1]); u  {, ^, G' p/ {# ?
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”# u0 j2 l8 b' ]* L0 V5 Y+ w, [
li[2][2]='ALL'
+ A. }% \; Q" r( j( ~print(li)# |: [2 r$ G: U0 B) h
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')% l0 \6 d4 h  E8 P& r- m
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ d' z1 M9 H0 Lprint(len(tu))3 A) F+ G- U* T) p7 f( H2 j" ^+ u
b. 获取元组的第 2 个元素，并输出
5 Y/ t7 X2 ^& ~3 r* {# r6 N9 f, a% e( cprint(tu[1])
9 ^$ u" p# v. z) r" G  a1 s4 je. 请使用 for、len、range 输出元组的索引
# }& G: l% G' b/ wfor i in range(len(tu)) :) K) \2 u: p" e; u8 x
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& l* \# R0 Z% L' U, ?; I/ ~2 Afor k,v in enumerate(tu,10) :  g& X) s3 H; j8 T
print(k,v)
0 l% ~' I+ o/ O10 alex
6 \4 {  O0 M1 Z11 eric( N" m' n/ K9 F4 _, _% M7 U, U
12 rain* V3 G2 [! R( W" [4 N7 R) }
9 o9 R4 }. p; x* i* [" f' `
for k in enumerate(tu,10) :
% s8 a. ^$ Z! ~9 }0 ^# l print(k)
% a8 s. k1 S. {. d% K# J' p(10, 'alex')
: L  e3 J* o: [+ ^(11, 'eric')
, f5 \5 t' r2 _2 ~! @6 c(12, 'rain')
' X; f3 p# [9 z9 ]7 u; P0 x' [3 Z
; _* u+ K9 v; a" r. P# k) D; f! C. ~5 v% o4 `& X! c; |
25、有如下变量，请实现要求的功能
5 Z) x6 a- n5 N" @6 T8 htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
! z+ z7 g& Y  l- q# V+ L6 |
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ }  z& X; a7 g0 p
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]), Q1 [! ?0 ~8 ~# M( ?- x- z' D
res=tu[1][2]['k2'].append('seven')
, [: n$ N. @6 w$ V1 M6 L
# I, I% i$ Z7 ?print(tu)" @4 k' S' b/ S4 X
26、字典+ ~9 }0 j' Y8 b( ]& T4 g! U- Q+ c1 d
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 v' m0 f3 N7 _2 R+ ]# x1 x7 { print(i)b. 请循环输出所有的 value/ s- z- m+ H; i6 q8 `, w
for i in dic:
6 }4 Y3 Q7 J1 \, r  \' \7 N  X6 } print(dic)
7 T: y- j8 d9 C$ Ac. 请循环输出所有的 key 和 valuefor i in dic:
" w( I+ n: j3 A! K( P( x8 {print(i,dic), {  q3 A6 }8 r. B
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 C2 A4 V9 Z4 Z& b0 D4 h5 mdic['k4']='v4'
: l, S' q9 p5 B# D) H7 t" uprint(dic)
' w5 P- h. {$ W% He. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 |9 J) U& t( m
dic['k1']='alex'6 o+ T# n6 c, }6 t
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典# n8 \1 r, q+ w6 k  @+ d
dic['k3'].append(44)
4 Y; C  x. n# o( [- aprint(dic). |! T" l4 Z. I
1 r) K6 v8 N+ p3 E: R" Z: A# X
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 ^" ]9 q9 ]! h7 i) ^2 d; `dic['k3'].insert(0,44)3 t7 X  G& |1 Z9 N; b$ m
print(dic)% D+ O2 E9 b0 T: u% j6 p2 k4 k
27、转换" o/ ]0 \* u0 ?) l9 D% h$ ]5 k
a. 将字符串 s = "alex" 转换成列表  s = "alex"" v1 f0 J. T, l4 L5 y
2 x' y6 G' j3 v* B( G
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  e9 R: ?  P5 @# |# ?, u2 rs = "alex"
& ?" U8 s$ S4 ~9 l0 Tprint(tuple(s))7 O, B) \1 }4 b' _* V" a

& K- r* Z1 {9 }  \  hb. 将列表 li = ["alex", "seven"] 转换成元组
& Q8 l* Q8 F9 g" k6 Dli = ["alex", "seven"]
/ ~" _8 E7 R. |; g8 Cprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 X& |1 m: m% m4 B/ ~  Ytu = ('Alex', "seven")
, v2 j7 V/ c5 l- q- O( A# Lli=list(tu)* m+ U* V7 E& |1 H& s2 U, k: w8 C* h
print(li)
8 U* u2 B: ~! L. I2 @( _$ w/ }# Q6 j1 ?# }  a. X

  M) P8 q. V. ^# f! T5 B! O2 Ld. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: M* J% B8 T; c7 l, b0 x; I$ {+ Q$ J6 k" k# ]& o
dic={}
5 Q% \) ^0 ]" z9 A) f8 H: zfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面! `* u3 m7 d( B9 N' B
dic[k]=v# T9 Q# h( ]# B, J3 m2 ?
print(dic)27、转码n = "老男孩") G- z+ x$ b' G/ i
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
- k1 s% L8 p8 j$ F) la=n.encode('utf-8')
0 E8 b1 U3 U% I' f, {# Fprint(a)
  U) p: B; W1 N1 eb=a.decode('utf-8')9 [4 C; \8 w/ ?: f4 \" f
print(b), ~4 ~7 W! d  P) I  t
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'). ]# ~& M( |) q7 s
print(a)1 @( |* {& J' v; |; K1 V; |, ^
b=a.decode('gbk')
& Q$ @/ P. D8 w/ z" Oprint(b)28、求 1-100 内的所有数的和4 y- `) G) f% R
count=1
) @# }5 e6 @1 V2 N  y- O' Isum=0+ Y/ y" N! r, S3 B
for i in range(100) :1 m) M! y+ ^  g. h! r2 j" t
sum=sum+count
7 o7 L  n" x6 J- j4 L9 m' ?$ K, G count+=1
; M; p: a+ Q) u. i. A3 S0 Cprint(sum)6 O* F4 t; r* y/ [' V
+ f& y: ~0 D8 }0 Y( N. I
count=1
2 a( ~# g: q2 \0 ]5 Q' gsum=0
; }5 n1 S) V5 V3 s, A5 U( Jwhile count<=100 :
% z- a" B5 b/ L5 { sum+=count
. T/ S- s. Y$ i. o9 Q' d count+=12 M, j3 |) F: s( C# O* E: t
print(sum)29、元素分类
: I# ]# P, X6 k9 b9 `" P$ P有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，% R8 z. F$ Y5 {4 K4 Z
将小于 66 的值保存至第二个 key 的值中。* y% ?& n9 O# r, e9 t- u
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}9 g0 v9 x9 }# P: d$ x
li=[11,22,33,44,55,66,77,88,99,90]- a# Z: U0 r% ^0 V( z
dic1={! v% s/ W+ D; J$ V
'max':[],& `4 Q  l3 c  a  F9 _
'min':[]* U7 `% O% c: V3 A* p: i2 t. A
}  ?) K* I, z7 u
for i in li :
* M1 `  o- W  f- Y if i <66 :' G5 H3 G, V$ F- b4 e
      dic1['min'].append(i)0 ~+ G0 U/ I' s
else:9 u7 }! d! Y$ |8 w: K
      dic1['max'].append(i). d$ t* D6 T/ t- F( Q
print(dic1)
3 L/ D9 a* X! Q4 W' H( I/ N6 |4 V) b: L) j; Z. @5 G
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}5 w2 n: z8 {1 m* `( Y. V) u& m7 H: A

Python基础知识汇总

主题推荐