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、写代码
- F8 N9 a' f6 Y3 g- q" k$ ^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) :8 y$ s* Z0 r& u  u) D7 y
name = input('name:').strip()
7 O2 j& C' s3 v/ |5 b6 V pwd = input('pwd：').strip()" @9 ]4 U2 g: R) f% e3 ]* }
2 E0 z( V, ?5 ^  x! f) p: M5 _
if name=='seven' and pwd=='123' :
# b9 `- X) c2 ^# R       print('ok')4 _& ~& [6 |* S. G0 r8 C; M
else:
! G- |; }& D9 \) p: d       print('error')
; F2 Z! \" d) j. m' S' |, e: T7 _       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)  :( }- f. z/ \# @- x
name = input('name: ')
' z6 g9 b6 [4 ^. ^2 I5 E pwd = input('pwd: ')& M0 @6 M  |8 Y, I2 o7 k
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 }+ b) b) l3 k8 r" ~) q; D, u       print('ok')
2 ~& S+ K$ X0 W: _ else :
2 |/ `. o: y% d& O       print('error')
9 }! K& `* C9 g4 x       count+=111、写代码2 C1 L: u/ s6 k7 n* j( r3 D
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) :
# B0 ~+ s  t4 t9 G& F5 s if i %2 != 0 :3 |+ q5 S$ l3 u& O, U# N. Q
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
& J- }9 x, G- e. W  c if i %2 == 0:
* I$ r& T+ F6 u0 z$ s% D3 F% d       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"
9 H+ Z! H2 R4 x4 P8 T4 xa. 移除 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)
  [8 Y% w7 K& ]8 V$ Rfor i in name:0 E0 f  D! X1 h* g7 d
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
& \. u) {" e4 i: n22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']' B# J0 Q, F2 O. t, O7 x3 v
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ' g& Y; L. {! I; {
print(li)
! X" M9 h3 I' \' d: \ ['alex', 'eric', 'rain', 'seven']
1 q" ?: ^$ A$ z  S7 d5 e! @c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- Z9 j% k* y  y9 |: Rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 H$ i+ M" |  i$ N3 D) `print(li). U3 D( p  c3 i, ]9 L
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']  w# g7 p) u/ h
li.pop(1)
, F8 T1 n7 _  j+ F* xprint(li) ['alex', 'rain']
  J" {  A+ \3 g指名道姓的删除li = ['alex', 'eric', 'rain']
2 o/ g, u( @' g- a" uli.remove('alex')
0 I9 |8 o- y% [/ Y( bprint(li)7 i" w9 v  ]/ E2 R. U8 R1 d5 u6 {5 @; e# _
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
1 S1 |" p3 f) z+ x" J; }4 kprint(li.pop(1))& `  L: G. G2 y; y. M
print(li)
5 F2 R2 ]; H/ Y
0 m- s4 W! B. C1 L. |5 r$ Oeric
- w- ^+ V- g& A['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']: f. ~8 g  s! `; T
del li[1:]: ]3 ~8 d% L9 J, k( P# M
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 Z" `9 u/ |& w5 @0 l! xli = ['alex', 'eric', 'rain']4 U+ u. Z3 W9 E8 Z+ E- a
for k,v in enumerate(li,1):
8 j* \# Q) x# x* f& O  K0 e print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]; @- Q6 P1 j9 r
a. 请输出 “Kelly”/ y; I% C7 y* U5 }7 `
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 V3 A( O! |0 h' Q6 k% n3 g2 A
print(li[2][1][1])" ?9 V! f/ `1 E( V9 _* h! [9 k
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”0 y' z' b! M$ x8 t1 v
li[2][2]='ALL'
2 z8 n' u5 G  a5 h1 ]print(li): E. ?0 ~# }; j" D7 i4 [  G# w
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')( n5 n3 i8 S6 D8 v9 V; X) |3 K! A3 K) D
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')8 p. e/ p% g+ o: b
print(len(tu))% o/ m' d* s6 j) X7 h
b. 获取元组的第 2 个元素，并输出
$ W( e. @0 K0 Y! y. ]7 _print(tu[1])
: J& V: A+ [, q( G8 _. Fe. 请使用 for、len、range 输出元组的索引$ }: `, R4 g; Z3 }% s( f) U' i
for i in range(len(tu)) :9 `1 _( B6 k' A9 x5 p3 K$ g
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)6 X) v& M0 W; I6 l) z4 S; ^
for k,v in enumerate(tu,10) :  p3 h2 S4 B6 }: \3 P
print(k,v)
9 t/ P" u! l& \. e. m) T10 alex
6 o% D# ~* \6 l% y( n, i" R- C0 E11 eric
9 G7 v6 R& h3 p) W( t- g12 rain3 y9 u. k+ P  T( M

8 L, Z, A0 ~# o2 \, v, {for k in enumerate(tu,10) :
$ G& A5 U0 |+ D$ U2 Y) B) q print(k)
5 w. S" @" ?$ P" Q! w- r(10, 'alex')- F. o4 [6 h* r  x3 N0 W7 ?
(11, 'eric')
: @& d/ D! T2 X2 Z4 L  @(12, 'rain')
, A6 r6 {2 ~9 `6 {! _
7 L: e2 z1 v+ x, i. y% B. ]( s6 P
: `+ o" \' k$ F( L  _. F8 s25、有如下变量，请实现要求的功能8 E9 |1 x4 X2 I+ W* U( R2 w1 g
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

, C; s- A9 e$ W$ P4 S. ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以5 h' O, T0 t3 z( l2 |5 y
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 N- v1 s- [$ Q7 H  N+ E- Zres=tu[1][2]['k2'].append('seven')3 Y  v& r* t& b  B4 x; B
& W# y( e9 E) j( H) y6 t
print(tu)
4 T' B' k- k9 b. H26、字典
$ s/ Q. ?9 k" x& r+ t- N3 f6 Hdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:( \5 v8 N3 O! W, M
print(i)b. 请循环输出所有的 value4 P8 z( n1 `0 A% M% m. f
for i in dic:. \" }. {2 I; d0 F7 t+ R0 ]4 q
print(dic)
  L7 w6 g0 h/ w( r4 O7 Oc. 请循环输出所有的 key 和 valuefor i in dic:1 o/ A8 _. S9 U" q( O8 S
print(i,dic)) W" Q1 f* y/ v7 B
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典% ~# n9 I# ?; A
dic['k4']='v4', b* B; i& v- \7 ?# |" `. X. ]
print(dic)6 B/ U1 w* O6 t5 {! W6 ^
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
8 E8 h5 J2 c% b' M  ydic['k1']='alex'
. d: [, D$ M2 G# fprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' X$ r; V0 v9 c" e* n% ^) {
dic['k3'].append(44)7 m/ w' n8 M6 ]( S2 S& J
print(dic): U4 d; e0 }+ y; \

# G: g" s( ^' F# \' \5 T: Og. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& o* v" l1 X/ A& [dic['k3'].insert(0,44), d- ^4 x8 S: ]* C7 \0 b
print(dic)( f0 c& h1 R6 m$ v; g
27、转换
( Q; @  Q# F* ~- Q( F: y7 Fa. 将字符串 s = "alex" 转换成列表  s = "alex"
; M$ Y- Z4 k! C0 q' f2 i, j
) d$ t! q/ k6 O5 X$ Iprint(list(s))b. 将字符串 s = "alex" 转换成元祖# ^) x; J/ W% S0 W
s = "alex"' @$ X8 N+ M6 R" t  R  L8 [2 v7 i, m/ N
print(tuple(s))
% [6 l; D7 a) Z+ x* B) }9 C# R; R2 h6 o; E
b. 将列表 li = ["alex", "seven"] 转换成元组: v9 B0 i% V6 Q4 ~8 \# _
li = ["alex", "seven"]
& ]1 ]% P4 o, `( K" h0 {8 [print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表7 F6 G5 O% d! b5 T- G7 O. ~
tu = ('Alex', "seven")
& S$ A( w/ }% }3 B3 c5 Ili=list(tu)
+ E( Z$ L* z! W8 `print(li)) }* u( i# d! Y2 r+ ^: N' g

: I  a: n) X" h, w4 W  h/ p  z) {5 x9 E
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
+ ^' A+ }4 o+ y) P% @- g+ q8 u+ O* a% m; s
dic={}$ [* T: t) Z7 G+ d1 W- ~
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
- d, q( H8 q! q; ? dic[k]=v
' z: E5 T* r  I& {4 a5 ` print(dic)27、转码n = "老男孩"7 x" h$ E: }2 e' `
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# y) a: ]0 R- s9 _a=n.encode('utf-8') 9 e; [6 k8 c; F" v& \* X3 n
print(a)) d3 `% X! n! ^# ]# W
b=a.decode('utf-8')* X* v1 K: Q8 A* p' A  b0 a
print(b)$ S. Y$ D# w! h1 t7 L, C- m
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')+ Z) x( `  o/ _; A9 F: M
print(a)
) c! l  W+ F  `4 Ib=a.decode('gbk'); C! v  P' B0 _0 r# }# K  F+ r
print(b)28、求 1-100 内的所有数的和
, y" L. J& {  }& c# Tcount=1
# k# O+ t" @7 [* Dsum=0
5 x# x  D( c" o$ a1 Gfor i in range(100) :4 E! n' J* }: @' v( g  r
sum=sum+count
0 F  C; i. I2 |8 u/ R/ z count+=1" t: _$ `; `! p9 X
print(sum)
. s$ U5 E2 d3 e: U
" v4 l! x: w  Gcount=1
. ?; Z2 V' F- R, Csum=0
1 h4 `  s2 p- Z5 |while count<=100 :
- Q; g5 N7 {2 o9 {2 C sum+=count
! s: y4 U/ A0 `% Q# e0 O/ A- { count+=1* Q/ g/ d5 q( n; _4 D
print(sum)29、元素分类) ]  G- G+ a. X+ }/ s- y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
6 j. B3 U4 ^3 _# @+ G5 g0 A将小于 66 的值保存至第二个 key 的值中。
% X$ K1 Y7 x* E6 q+ Q( R即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}3 V, y/ u2 \0 N2 l& W( L
li=[11,22,33,44,55,66,77,88,99,90]
. N( y, L/ h% {: g0 a1 ~dic1={
6 q) y6 i4 Y  `2 I( N 'max':[],
8 o7 a- H" f( f1 h# f+ f 'min':[]
, q  W: g& ]+ X/ ]) W! C}
6 c! e) W. O* L; H  E) n+ w7 zfor i in li :7 C; @0 b# h% O& Z: T( k$ q
if i <66 :
4 q1 w2 R$ H, m       dic1['min'].append(i)5 B/ q  b9 ^& ^3 }- e
else:! H, Y' f; e3 P- x" n
      dic1['max'].append(i)' K: l& C8 n( c. F1 o6 V& }
print(dic1)2 k/ X* K2 F" ?
- A  l5 _  u3 r! a0 o
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
/ L. _1 o  n" z+ y* J( |

Python基础知识汇总

主题推荐