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、写代码5 l* A. s3 T/ N2 ?& v) {' B
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) :' l6 ^% S: J0 G% H. B! Y
name = input('name:').strip()+ s9 V7 p: N5 `. u' [
pwd = input('pwd：').strip()) R; Q+ I7 b- ?: F: f" b5 [+ o

" y, A5 R. @- S8 u" S* {$ z& R2 u if name=='seven' and pwd=='123' :9 w% q- n# w$ N* ~9 k! q
      print('ok')
1 i; x& I) d$ s2 V, n1 g2 g* p else:# m) }* Q% ^$ n! P) e( A, y
      print('error')
0 e* n' `4 K0 S, E       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)  :& |- Q. F- I( Q" W! K, f0 ?; r7 Z
name = input('name: ')
' i/ s' \/ J7 W4 \* G pwd = input('pwd: ')
' u/ v& O) Z7 p2 [# a if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':* k) B2 k% V  }: m5 x5 j" [" o! [
      print('ok'): W& C8 x; v* V4 }& b' H: U+ F7 f' ?
else :! ]4 A) W; y; I" L- W  E
      print('error')
0 L3 F, O7 o/ I; q9 K$ A2 ]0 S       count+=111、写代码
* {) ~  [/ D6 x0 S6 Ca. 使用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) :- f- m' Q8 {) ~7 u
if i %2 != 0 :
& F4 Y5 \* j( l) g: I2 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) :
% |0 x) t" r8 I2 S! H: N if i %2 == 0:
& d1 L+ v" p0 u) p. l" r5 y       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"
& Y; c6 Q% q6 i: ~7 H2 ma. 移除 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)( s- `' r% S& D2 z  c5 M% H8 N* o
for i in name:
8 v; ]# U  R1 U) H" R% r1 U print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain) i& v$ g& _. n; s8 _
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  c- h4 O0 }1 W1 }
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
7 |% Q* w  f0 L& z) Kprint(li)7 C& Q- C# q+ l- ?
['alex', 'eric', 'rain', 'seven']
( x" }, Z# x. _8 I6 r5 Ic. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')" Y( o: c; b) b6 {0 c& j
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')2 @, h3 z! k! n, ]; I4 K
print(li): y8 l, y' Z; ]+ O$ R1 g
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 @' Z4 q( C$ f! B, Xli.pop(1)
$ L8 Z/ Q& I, z4 Jprint(li) ['alex', 'rain']
( T2 s& _; [; _2 ~指名道姓的删除li = ['alex', 'eric', 'rain']  I2 l4 T' D# M9 {' p* t
li.remove('alex')
; P) M; F. H4 u* Fprint(li)
; ]: v; K) b  ^1 b' J$ tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 l, K, N% {5 Q2 J* l2 K
print(li.pop(1))
2 z. n5 W8 v: e7 e: p: Iprint(li)
% I2 @9 G5 s  E1 Y# r: _. n1 d, K, E* W/ Y, n8 x" i( W( }
eric
- x" L7 u) F+ n! M$ o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
7 r+ W# X) _2 e8 [% b4 fdel li[1:]' g# I1 t7 {5 J9 X0 e  h
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 m* n( {( X- o$ J6 }& l& ]5 Lli = ['alex', 'eric', 'rain']
6 |- p1 O( z# xfor k,v in enumerate(li,1):
3 \* j8 L8 A, j" p5 p# b: X print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" R3 K2 p" Z- c: ^$ ?+ {* q: Ea. 请输出 “Kelly”% k0 f' \- T. ^6 E+ Q- S: G
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]6 `' A: W" L' G: [! h. t
print(li[2][1][1])1 w% g: |0 P6 g8 ^9 a
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- Q/ I7 _* o/ ]) I# w  hli[2][2]='ALL'' x" K7 E% A* \" c, @
print(li)- \8 @) S8 O& _
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
+ L# l; Q0 z0 _, ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ |1 T( H# ]! Z  V; `print(len(tu))5 o( J6 @. x5 g) X8 E
b. 获取元组的第 2 个元素，并输出
: T2 ?' s2 D& p3 u! v& Gprint(tu[1])  B) }  V+ K, V4 t
e. 请使用 for、len、range 输出元组的索引9 m+ x5 w$ i* C3 B6 T6 |
for i in range(len(tu)) :0 i) Z& V2 e, W8 N% H
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 R# q; ~2 n' \, ?. @8 i6 Kfor k,v in enumerate(tu,10) :6 }- s8 \; Y1 ^( q
print(k,v)9 c& [7 V* W7 h
10 alex' ^# U! Y, V; I0 t& K$ o
11 eric; l( y+ e. Z& _* \* I8 s0 X' \/ {
12 rain
# J/ ~1 C$ M2 k9 u! V
. q( c1 ~* m6 z  ifor k in enumerate(tu,10) :
  ?9 h% T" G2 a0 C, [+ ? print(k)2 l0 X5 K+ U6 z1 h
(10, 'alex')
+ V4 a4 _. W+ E! X. J: W+ G& z+ w(11, 'eric')
. p; b/ }* W. h) u2 u" `, ?(12, 'rain')4 m' C; i0 s8 m9 u+ C' J% F

6 D$ t5 u" S# ^7 Z/ t# s! H% T' F% |, f) g3 ~5 B
25、有如下变量，请实现要求的功能
2 `, Q. H* o& m9 L2 mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
* N" n) r8 @3 N: F; C/ D* x
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以" M0 g+ Y9 }' T1 a! E1 w+ Y: k5 p
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])8 ?$ ~0 `7 V1 \* H0 [
res=tu[1][2]['k2'].append('seven')# N* N1 r/ a" d6 |- `, J! l

( p& U2 y, L# ]  t3 z  n' Wprint(tu)
6 U1 s$ E% M$ U26、字典3 c9 K- Y& U$ Z
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; O- U2 P0 ^1 l5 J; @ print(i)b. 请循环输出所有的 value& ^6 O/ m! \+ p- l) C9 q
for i in dic:
, J. l' Y% Y: |' q print(dic)" j# d/ N/ B7 L& X
c. 请循环输出所有的 key 和 valuefor i in dic:
. a: E0 j- ]# v* h2 pprint(i,dic)3 |% J5 x! R% }$ S
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& ^& S: P, H; h% j) A; pdic['k4']='v4'0 S2 ]! u. D, O
print(dic)+ ~8 s& _) N& f0 @5 i
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
1 m3 |1 A( d6 M% t1 M6 rdic['k1']='alex'
8 a, U. d6 {! a6 t8 Z# e* uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' C) m8 K1 g# P
dic['k3'].append(44)$ x0 s$ o4 @1 i" O
print(dic)
& r  p3 @! C5 W; o
, k0 Y; ~# Y2 qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ A. t$ T. V! h! l7 J! s4 x( K0 ^% adic['k3'].insert(0,44)
( C  J7 R$ L+ t* A) sprint(dic)7 U5 ]9 b8 p8 Y8 r. i
27、转换4 S( w5 j2 j0 k
a. 将字符串 s = "alex" 转换成列表  s = "alex"$ ?2 f9 v/ L% ?; X& G% \& i
. Q: X: L3 A6 ]% Z: E) p; Q
print(list(s))b. 将字符串 s = "alex" 转换成元祖
5 O$ |3 N2 V' }7 O+ D# P7 ys = "alex"
8 I2 R+ j0 F, H6 G2 K0 m6 c3 M* Z1 bprint(tuple(s))
9 u4 @8 x  Q' X7 X0 A/ U, S& d9 v& a1 `
b. 将列表 li = ["alex", "seven"] 转换成元组
1 q9 f6 |2 {" wli = ["alex", "seven"]
$ D8 k9 `& r: Y. s; _: P4 P; o5 Cprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 p% q( Y5 U5 ?/ ?tu = ('Alex', "seven")
$ J2 b5 `; v. K8 u' n! rli=list(tu)
% P: @' \( u5 aprint(li)
( g& y2 V1 K  X! p) U: Q2 Q3 j! `8 v$ n' `! \2 Z0 F

$ T2 ?) P& j, G5 F" N/ U1 F% q* Nd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增: X$ V! s. Z# n
8 ?- x! I8 C0 V3 ]2 ?
dic={}
9 E/ @% S( l$ g! i. r4 ~for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 t3 R1 U) }; N8 n% M dic[k]=v2 ?& E, {$ O6 A6 d
print(dic)27、转码n = "老男孩"( W8 o7 n* R# ?8 X; k
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"  ~4 C" T0 N' C. m! h
a=n.encode('utf-8')
- R. n. }$ [- u! X1 J1 aprint(a)6 k/ y. ^% s- i3 W4 h. T
b=a.decode('utf-8')
/ I, H, A) m0 S. x, gprint(b)$ X$ z8 o3 D  i# C( Y# Z9 r
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
8 x8 h( X0 g7 aprint(a)) H- Z4 `6 E0 j: ^: P
b=a.decode('gbk')
9 O5 s! A- v. I2 Tprint(b)28、求 1-100 内的所有数的和
4 W2 v5 P6 ?. k' e9 N6 Rcount=1
* z: k, k+ w6 T4 O% ~/ [sum=0
* Y& H( z2 H, Tfor i in range(100) :
% q( v2 _* |& M1 b' H sum=sum+count
: ~) @  R5 M! ]* q count+=1
$ ~# O+ U: m4 g) \* M9 G$ ~print(sum)/ l' J7 w, o* A

1 N+ |, r2 N' g  R0 r/ ^* ?count=1) N6 [1 x3 L3 ~! G1 i, |6 g
sum=0- F) T8 _# _& x4 ]% O
while count<=100 :
( w: I+ O' v; w9 [6 i4 | sum+=count
8 B* V! h& v+ Z0 z5 u count+=11 H! u& i6 Y& W
print(sum)29、元素分类# J- `) L. K5 E
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, W% ~1 g* G1 p! r+ q5 r" Z& G将小于 66 的值保存至第二个 key 的值中。
. r$ l2 X2 r8 z即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}% \' O5 z( g5 H9 T( T4 A7 _
li=[11,22,33,44,55,66,77,88,99,90]
2 y* ~9 B, w- P1 ]dic1={
! k% @3 y$ [1 ]. j; p 'max':[],! M* P% V* F- m, ^8 z) I& J+ T
'min':[]3 G! e3 G& D* w
}& K, [5 Y- _. [9 }
for i in li :. p, G3 \2 T, ^( m
if i <66 :4 P3 U& v" n% Q
      dic1['min'].append(i)
8 z2 Y+ `2 T: X8 }$ P+ U else:) g( r- u1 O& U# A2 F$ H
      dic1['max'].append(i)
- x5 |  P" {* @$ J/ M3 Yprint(dic1)
5 \9 U) I0 Q( S1 r$ ~* h1 Y6 b& \
+ Y/ B# U' r, g4 i- E" [+ g6 F6 Y- j---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) N6 [1 J/ Y7 p' G

Python基础知识汇总

主题推荐