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、写代码. [0 Y. b% T: u
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) :
- Q# C7 b0 r/ M( {( t% ~ name = input('name:').strip()5 C& d" ]* s  t" x* L
pwd = input('pwd：').strip()
- F: Q  c# e' q& x( T& ?4 |% z7 V  A7 L: k% q" T+ I
if name=='seven' and pwd=='123' :
8 f, Z  Z' Y# m( z9 q       print('ok')
3 g' Q: T; d/ s+ W! l7 W" B8 ^ else:
2 k5 B0 L$ h% R( k       print('error')
( q% W0 S: f. 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)  :
- @& K. W4 f/ \9 A3 ^/ w+ U/ o name = input('name: ')
" l; _$ t" W) Z7 J: l5 x6 g# Z pwd = input('pwd: '), v2 G/ N- r5 U7 ~
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':6 h2 l- _3 U- R# ?
      print('ok')+ u8 q8 J/ n, \# L" H
else :4 N0 J$ H+ z4 j1 O+ d' E% K
      print('error')- p5 v) w4 T' I5 z. n& l  x/ d7 O
      count+=111、写代码! b, d( H/ E8 J% 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) :# |! w( l: F( L& M, _
if i %2 != 0 :( S- w( Y! w' E. C1 v* G
      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 u% ~! x- [' j! ?) o/ c if i %2 == 0:* P2 l4 x, e1 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"1 H9 q- T1 ]% y* [* o
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)7 i8 |9 X& V# ~* I% a7 E# Y
for i in name:
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain- x  ~$ _$ U6 V& c( ^- h, @
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- `+ j( _5 l8 A! [8 u
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    2 @% L1 B& L2 z% G0 K+ j
print(li)
; j, b  a6 p# ~4 o1 g. U" [ ['alex', 'eric', 'rain', 'seven']1 g- R3 c7 B* `* X3 v$ C) A, W7 \
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 w& m$ j1 j- t3 z$ R+ kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')& _$ O) e9 j0 C
print(li): ~3 O# Z9 ^! Q% X% F# B5 }
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']( u8 k. ?2 A6 T+ E! v
li.pop(1)
% R% ^# z# P4 |" a8 c' zprint(li) ['alex', 'rain']# r! V7 ?0 i, B# e
指名道姓的删除li = ['alex', 'eric', 'rain']
) u& }5 s6 A4 Q1 L; eli.remove('alex')
5 E7 ^, G* ?* ^print(li)& K* t" U- ^4 b
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']; y( O, g; A  i+ L) Y
print(li.pop(1))( N' w; M: s: V+ |! _
print(li)
& O% s  B+ I7 [  Y2 p9 x' \% E- C' @' j
eric: |" R3 F3 a& n7 l) n
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
3 S0 U/ c# k0 L# H8 Adel li[1:]! R4 T4 j2 h7 e) s
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)" ?* z2 [7 M4 y/ @
li = ['alex', 'eric', 'rain']
5 A( Q- P9 Y7 I. {& }! l9 [7 zfor k,v in enumerate(li,1):
9 ?/ U" Y9 i$ ?$ A& _, w+ D' M& s& ` print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" N$ T2 W, b9 f/ j* m  Ha. 请输出 “Kelly”* P- q& c8 ?8 \* ~
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; V) }' b& D4 Wprint(li[2][1][1])* P' V6 v5 c& v9 \, T6 V& z
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 k7 _# [) Q3 ?8 r9 N. s" v) }. U
li[2][2]='ALL'
9 C( u; [3 v" @7 qprint(li)) W* }7 `0 o) h8 a6 U9 _; @
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')" e: b; h7 ^! I; R
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
3 q5 k) E9 o# T2 B9 p# S% Jprint(len(tu))
1 k" t5 k7 w  `9 ?; jb. 获取元组的第 2 个元素，并输出6 |$ i, O. O. ~) l6 i! h, Y$ @! j
print(tu[1])5 l( t; X, k+ O" m9 b
e. 请使用 for、len、range 输出元组的索引
% N2 @8 o4 {3 @5 Pfor i in range(len(tu)) :. R* @7 u  U" ~5 }6 {  M
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)$ s- p8 r' E5 J! ~* I" e8 [
for k,v in enumerate(tu,10) :
- D0 L" i' v1 M  p print(k,v)% I, J; N, |4 f
10 alex
  w/ x. P" i6 X  J11 eric+ D) P, t8 v0 E" \
12 rain# W- |- z( l" o

- }2 B, u$ k) C9 A8 I; Vfor k in enumerate(tu,10) :' S' A  r8 }' W) D
print(k): v8 F" v% z4 k8 B5 y
(10, 'alex'): p4 ]) G# j2 M3 a
(11, 'eric')  ?/ Z: B4 s( p* z8 g
(12, 'rain')/ x" w6 j% H5 Q9 [% G4 u
0 F  Q9 O% a, m; u4 Z& }$ I( C/ Z9 L
' D1 M( k2 }$ i2 V3 i( m7 D
25、有如下变量，请实现要求的功能
+ U/ F0 _7 x0 y3 o9 Y! Y- n  Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
: `' q7 H+ [+ K+ G3 I, K
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
9 c# m3 ?2 _* Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ Y. @. z: H! A* _9 Bres=tu[1][2]['k2'].append('seven')7 R8 @5 x0 m/ A) ?* j7 `% M

, c( Y' u( R% F! P" d3 iprint(tu)
* G1 O; z6 p$ t" n+ m26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  w* z3 j  L8 n. U; V* D7 M4 s print(i)b. 请循环输出所有的 value0 o6 a! R' ?" w4 c- N
for i in dic:
' O8 z' K( o1 l& z9 G& }2 t; J print(dic)
( e: U' K; u, g9 h- U3 M& K2 }c. 请循环输出所有的 key 和 valuefor i in dic:9 b4 Z0 \9 q( Z  }# m; Y8 G1 ^2 T
print(i,dic)
) H2 o( e# J$ o0 t& A+ Id. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& Y# O1 l" f" Z) j+ S; Sdic['k4']='v4'' S) ^" [; c4 z5 `3 a
print(dic)0 {% x/ m8 p3 D! v7 X' _! i
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: n( C2 T' E% f# B  Y
dic['k1']='alex'
( B( O$ @: H7 D$ d' D( T8 M2 P. Aprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' H; g: ^2 U$ M* Edic['k3'].append(44)% U) _& d( V4 L/ Q" u; _! S
print(dic)
3 @. h% f0 \! z, n1 l0 V4 a2 i4 {$ h
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 a; K# N: ?* g4 Z' b% q1 sdic['k3'].insert(0,44)
% {9 ]+ X7 O. Z7 {2 {+ M* oprint(dic)  B) K  g$ |9 L. u- }+ Q
27、转换
4 w$ Q- N, p$ d* |a. 将字符串 s = "alex" 转换成列表  s = "alex", D# b, k/ d/ G) {8 W# y% X- Q
  K6 y# F3 g& }% \
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" u5 w: |/ L" d1 f( Ys = "alex"
, I) G- l3 z) [0 K- s! tprint(tuple(s))
( B3 B) k* P2 A" b1 B- y; H& g/ U! C, h, c* x) s* o9 t: v
b. 将列表 li = ["alex", "seven"] 转换成元组1 @  P: b2 h  p0 T! E0 U, h
li = ["alex", "seven"]' r; L5 r  ]6 k, a' m
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
: U3 f- ~. a! @6 i( P8 I9 `tu = ('Alex', "seven")
1 j+ [2 ?6 j- Uli=list(tu)
( l7 P4 |' R, M  L& X8 p0 F$ aprint(li). U: L# @9 A8 ^, F

/ D8 f8 S5 P" @, T
, J+ F# s: j/ ?: W, s5 Id. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增- O- }: ]% l4 \* i& X
! Z$ w4 j0 I3 B9 i) o
dic={}
7 r! P2 A' `# P0 Qfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面4 n. L$ U1 I- A% W) b4 W. R0 y
dic[k]=v/ I. a* E9 d% ~; M# f( A
print(dic)27、转码n = "老男孩"1 Y: l5 L2 }+ c" d
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, v( w  C, {5 [$ R# w% Y& ra=n.encode('utf-8')
0 ^7 _! x0 ]$ L4 @2 r* {4 x; Tprint(a)
& ~" L$ _, V' I: Eb=a.decode('utf-8')
) A$ {+ {2 Y3 U/ }' Iprint(b)
; A/ q  {# w) l" S8 I# `6 Kb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')( L' V3 M3 m7 x/ ?3 m) L6 u
print(a)0 s2 U0 I4 N3 P
b=a.decode('gbk'): j/ m' ~6 b6 r6 D/ M% @
print(b)28、求 1-100 内的所有数的和
" n. t: G. [, Icount=1
& [! H0 B  p. E! X8 S% Msum=00 p9 L+ n# b% ?% I
for i in range(100) :6 R, n+ Q: C6 A1 C) T& Q- k" g2 y
sum=sum+count4 i6 ~8 m3 \; j9 V
count+=1
7 w7 a0 C$ B' `3 c+ o4 U  dprint(sum)2 X! V( t& D" y9 a* J8 Z
- r# Y" j3 H9 `) ]/ ?' z0 a$ R
count=1$ z& f9 Z& [. o6 N) Q0 \) [( W( i7 {0 O
sum=0% T6 s+ b# \5 a! P2 ~! r
while count<=100 :$ j( a8 G% K" w/ R  t4 a! i
sum+=count  `: U' {& P; r( ?, n
count+=17 p: _6 m# e8 ?' E
print(sum)29、元素分类: {/ s+ G7 g7 e; f
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，; e; {$ U0 E3 V; g6 B/ s
将小于 66 的值保存至第二个 key 的值中。/ Z) r! F0 H0 A
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}( Q* G# V5 A6 I! G8 i
li=[11,22,33,44,55,66,77,88,99,90]
. {2 Y/ @; \% `8 Mdic1={
  e9 J' ^5 C- {  |: ]* d 'max':[],
9 G2 s1 I4 T6 L: b7 l& F 'min':[]* N) M- Z4 p6 \/ f! C/ q8 }! j
}
/ t% p4 \2 d' L( r- y: `for i in li :
( F( i8 ~+ [/ m  K  p. } if i <66 :4 q1 B% t  x% ]+ R
      dic1['min'].append(i)3 c& Z0 @- b' \
else:
* \8 B: _7 f% G; C; h0 p       dic1['max'].append(i)
$ W, x1 X; @; h" fprint(dic1)
3 P) t0 O) n' W/ Z4 T/ B( v+ b) G$ b. I! r+ A: o+ Z# W
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 @' k/ U+ N* S5 J

Python基础知识汇总

主题推荐