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、写代码! t; K  Q5 a( D1 y- |' F8 X
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) :
! v' w% I4 U0 m* r: h# { name = input('name:').strip()& A( N) T1 q6 G1 y6 m8 z1 M
pwd = input('pwd：').strip()
1 |; g1 R. M- C: v, g  X3 }. H/ @: B: p
if name=='seven' and pwd=='123' :, m# K9 _, P0 ~* k9 t  n
      print('ok')" N+ C- \0 q+ O! M0 }
else:
# }# m' M$ S4 G# d' V: k3 m: @       print('error')
& a) D  g: U. \  {7 k$ b' ?; A- [       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)  :* E$ |# x% c" n  K  I; b5 z7 A
name = input('name: ')
# y8 f3 q" V, a( _+ i6 H( S pwd = input('pwd: ')
) w' Y6 _- L( {" ?3 z if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':: ~/ W: u5 T. l0 p# L; l, T* H
      print('ok')
8 X3 l( }8 N! W' x else :; Q* ?1 h8 g  W( n; `1 |( O
      print('error')( G. I2 L" B" U; m! k
      count+=111、写代码
9 U  O% q. R5 I$ S6 pa. 使用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) :& T: h8 S4 F/ D2 Z) v9 ^) R
if i %2 != 0 :( f4 z6 ~  F9 x. ?: f
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 r7 M% p0 f. p, S" P  f5 ^; r if i %2 == 0:
# r2 a* R: ~' P1 v( T# i( S       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"/ h) [3 }# N( L' U
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)
  k, ~' H9 V- V. ~9 E, h" Nfor i in name:& _$ ~1 T; W" X. K  P
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 N/ g$ r6 w2 ]
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, x4 z' m& q: x& ^3 L( L2 Tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
7 L, o; L2 s$ |9 P7 F8 J' Eprint(li)* b: n' O$ o% s" s* ~# z& E
['alex', 'eric', 'rain', 'seven']# g9 }" ~0 }$ w5 d0 G
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
$ @/ {4 ~( i9 j" sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')+ k% m; D6 d: |' P
print(li)
4 S% G6 ^: M$ G2 r) B% r" Le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
1 g% x; _# s0 F6 c( J* R9 @' Kli.pop(1)
' e  G6 K. q% K8 k  y5 W  ~print(li) ['alex', 'rain']2 P# D$ r* @. f0 ~4 ]+ [4 G5 G
指名道姓的删除li = ['alex', 'eric', 'rain']
1 m/ H6 P* l- ~! x0 }li.remove('alex')8 C! O, L2 d5 {( W: }! `6 v  s
print(li)5 `$ y2 R. f( b; R5 x# c( T* ^: `
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
& ^6 X: c( J5 t; w) |8 @! nprint(li.pop(1))
2 _  E; S, u! a) K! n' nprint(li)
" p* B6 k# w6 D8 p2 l& [! p" L2 d0 u7 \2 Y, w& f% f/ L
eric5 f% j7 A& r' R1 q* X$ o
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']  k8 E+ U/ e( n+ f  q) I
del li[1:]
5 c0 N+ Y  ^) y2 Y# I5 pprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
% `4 |; T+ E% R; d7 N) `3 O  s! xli = ['alex', 'eric', 'rain']
* o; _7 z+ V/ q/ h: K1 [for k,v in enumerate(li,1):
, G) y6 t4 s: C( x* p print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 ?: h( I. \0 k# J2 h3 e
a. 请输出 “Kelly”
' Y- o) W. N- l, b+ a, E" l' Oli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ H# O7 H7 Z& Lprint(li[2][1][1])' _& t5 p: x+ J( O  e$ M
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
! ~! p& s# k6 v" |li[2][2]='ALL'
  p* o  _& D9 T0 u5 qprint(li)6 V% z' t& G5 N/ G9 n
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 ]8 y9 S8 L) N* ra. 计算元组长度并输出tu = ('alex', 'eric', 'rain')& C" A6 d, z5 s3 K, Q7 |4 e
print(len(tu))
$ j/ u5 l* N, r0 x1 m: s1 J; Z1 f+ }+ Bb. 获取元组的第 2 个元素，并输出, `2 Y  G+ x# }! i6 I- o: `
print(tu[1])/ l9 \& K9 N  y& m' n- _, O
e. 请使用 for、len、range 输出元组的索引
6 |/ D  i0 k. g! c* B: T8 [3 Yfor i in range(len(tu)) :
5 {* w, |. v: j& p+ q) I print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)5 k4 Z) a1 S0 W) L4 q3 F4 z9 t- Q
for k,v in enumerate(tu,10) :
, x8 v* H3 Z/ V' h, |; H print(k,v)
- L& g1 o9 Z9 ]1 e$ a10 alex$ u0 d) S4 s' n2 G. B8 }' h2 N7 \! g0 p
11 eric
. j4 q7 N$ R1 t" I# L; V3 ]; d12 rain1 W5 p7 P6 @9 U
  B9 W0 H% j0 r
for k in enumerate(tu,10) :2 i1 a* Y* ^7 D" }
print(k)
' l5 i1 F- X; ?+ j(10, 'alex')' a8 D  K" I! _) F% R
(11, 'eric')  J1 v' u& ?; X* Z' O, g# |. `6 o
(12, 'rain')
( h0 m+ i7 i& Y9 _! c, C% W/ S  W+ W

4 `0 ?& h# a- `* i/ b25、有如下变量，请实现要求的功能
7 _. ?" D/ {* m! s4 |/ rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
/ B) R  I9 N* N- T
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以2 p+ f: y9 U$ j- ~0 v/ k
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 x7 f% {  f' @" Z0 O) Gres=tu[1][2]['k2'].append('seven')
7 F( x+ q& g0 p7 T- @
, q; T% S. ~: Y) S+ t* t. C/ P  jprint(tu). q0 {" H' @9 Z7 m2 L2 ?
26、字典& P" k9 ~' C8 d, i, C# y- H
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
! s% ^3 D$ s$ a3 l5 P1 Y( S# V print(i)b. 请循环输出所有的 value
( t& K; _0 v1 i3 n7 \& P: _for i in dic:
* b0 \1 G  p' y: X, W! D* K print(dic); D6 G: g$ V6 v" J, q! W+ k% Z
c. 请循环输出所有的 key 和 valuefor i in dic:
3 X7 g5 N8 [. |; e: P4 Cprint(i,dic)
3 v( R9 i0 e5 F  S1 K8 dd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典9 O8 Q# D# m5 q, C
dic['k4']='v4', ^8 {. h$ Y/ G# I' j
print(dic)5 F: x! H4 v" S" j
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典- e9 ]! ^" w  O. v/ `* I
dic['k1']='alex', E/ b$ L, E, T- n/ ~' g4 z$ p
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! R% l7 c6 e; {" Rdic['k3'].append(44)
' |, z* R- u$ jprint(dic)
, F8 p& T4 a/ e: f1 G& d1 f
$ j/ c9 W: W: G$ c- Q9 Qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典# C0 U- y; J0 |9 o0 ~
dic['k3'].insert(0,44)* g- d& {% E% C% h4 F: C
print(dic)
1 a& c7 S" m. p# c* u* Z27、转换
2 e$ C$ M# ]4 B, H; l' L+ va. 将字符串 s = "alex" 转换成列表  s = "alex"+ `3 k6 |3 |2 e" ]; q: w- m; u
- W/ T7 T- g% E" A8 i
print(list(s))b. 将字符串 s = "alex" 转换成元祖) c: F5 V, \" A" T6 Q2 a' p9 S
s = "alex"
, C; ^7 V8 j- l% D. ^. Cprint(tuple(s))" L/ U0 B: z) K! e+ a

. V3 y, t3 U4 ~7 _& Bb. 将列表 li = ["alex", "seven"] 转换成元组# A) q8 B1 N6 B* Z' z
li = ["alex", "seven"]- d$ K+ g# k. `- c6 A, y
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 _/ X, k- F. b* W# ?tu = ('Alex', "seven"): V1 `' a( }# L8 F4 `0 H% k  x% v
li=list(tu)
7 G+ w7 \: u& A3 [; q. Qprint(li)' [6 n# L0 C3 H* ^

5 J1 G3 R6 D) {* Y. E2 [
; }. d# }! ^+ F+ Ld. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
$ _2 D! R2 `. _6 W. H& e4 Y, _  Q) K, F: t2 E; I
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面; M4 S1 ^6 B: S& _- F" {
dic[k]=v
2 z8 a- ]( z9 ] print(dic)27、转码n = "老男孩"
- `0 a& F5 M7 X9 q. Fa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# K( L4 }+ i$ h2 La=n.encode('utf-8') " b1 l4 [1 m3 K6 k/ {
print(a)
' |' x( i" X- I4 J! V6 M$ W% ib=a.decode('utf-8')2 ~* ~$ }1 }% g" ~4 g4 t  F
print(b). z: U, g0 V% v+ O; w
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: d6 @, B0 w2 }2 ]3 V7 lprint(a)+ y/ O, m  O* w. T
b=a.decode('gbk')5 ?* |. J7 M1 [1 ^7 `( o" }! z
print(b)28、求 1-100 内的所有数的和8 z5 a& _: v. J
count=1+ E. @! E$ @7 U2 v5 r8 @; @4 U1 n
sum=00 |* ^3 z4 ?3 v  e
for i in range(100) :4 B" x0 S9 A5 n4 z0 l7 f
sum=sum+count
5 F$ Q6 e$ p  D8 g4 M9 _. d count+=12 z. @3 F# _: R* z& k3 ^3 O. Y* V
print(sum)6 A8 e. [- w: s* q$ V" u" R

# z" L% g1 v# Wcount=1
$ W+ x7 G' F# I3 c& csum=0
. [# i" O; M* v) qwhile count<=100 :, F4 d% U' e9 g
sum+=count
+ _. n& Q4 y3 d% e! @" a( `8 U count+=1
- ^+ F4 Z$ _6 }6 W. s& w6 ]print(sum)29、元素分类, g& G; h. n) h) `
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
3 E1 Z$ B) b# t4 t: u! r) z7 r! z将小于 66 的值保存至第二个 key 的值中。+ |8 w4 J" u+ ^5 y/ G" `' F1 S' \# `
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}9 E1 ~9 k# W- }, u9 y! M
li=[11,22,33,44,55,66,77,88,99,90]
# \# p# U3 Z/ e# b6 Q$ Ndic1={; h0 \3 N9 b) `* _
'max':[],7 e% ~7 W2 [6 _, x0 e! @
'min':[]3 p& _( y* t1 C! {5 A) @
}, t; ^9 z! y. V
for i in li :5 B1 s* ]. b- h! B7 T
if i <66 :
, x4 _7 |2 T8 N0 w+ P; i       dic1['min'].append(i)
+ h8 l' S% |" T4 Z else:* |" }0 R$ m. S$ b# N, H
      dic1['max'].append(i)
/ s6 j- D! D0 X( |' K% I% |- ?. qprint(dic1)5 X( a  M4 a! q% c

: m  X8 s  @5 H  U& o---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}6 {  g+ A- I! p

Python基础知识汇总

主题推荐