Python基础知识汇总

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 单行注释和多行注释分别用什么?

单行注释  #

多行注释  """  """三个双引号或是三个单 引号把要解释的内容放中间， ‘’‘  ’’’

% A/ U) l5 m: S$ W- f% W6、声明变量注意事项有那些?

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

3 Q3 o& g( F, F2 V" N. \" ^8、如何查看变量在内存中的地址?
z=1
, H8 V) S3 C! r7 Z; Qprint(id(z))
5 w+ n: G& P( q! p1 r8 ~9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
) {& [7 u& l" b; d; `# vname=input('name:').strip()
pwd=input('pwd：').strip()
7 B8 y3 i6 o1 Iif name=='seven' and pwd=='123' :
/ I$ w2 Q+ F* u/ Q    print('ok')
else:
7 a( v5 T. l( }9 i! E& t( H    print('error')

0 R' N/ f( b3 c, |- z0 S+ Fb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
% J, o# G; J: t  j! cwhile count<=3 :
    name = input('name:').strip()
. I2 B( J$ y1 \: O    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
  O9 V! |2 W. ^        print('ok')
    else:
" K2 e" C3 d8 Y* w0 l2 k& U0 B        print('error')
) P. x; `1 s/ D: s2 g( s4 N        count += 1
' E. K; k/ ^/ q4 i) A5 ofor循环：
5 A( T. {; Q- v& M5 p# Ufor count in range(3) :
2 s7 P. o! b8 p0 Q    name = input('name:').strip()
    pwd = input('pwd：').strip()
' S' l4 [& x- t7 _& ^5 H( |* i
    if name=='seven' and pwd=='123' :
        print('ok')
$ ?! N; ^% Z  p( j' i    else:
        print('error')
2 F6 M/ f* z5 |3 X% _        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
( \. z  K' L" S% I& a0 ^) Fwhile count<=3 :
) V/ q+ q( j3 ~$ h: I) F. I    name = input('name: ')
/ p1 y* d6 t2 a- q( d: {6 O" N    pwd = input('pwd: ')
' {2 u. e' A) {7 c! Z/ k" j4 t    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
, i5 U: T* M) F" ^) H6 l        print('ok')
9 Q- X% ~2 E( u1 L3 b  n    else :
  Q3 H! K" P0 V; p4 y' @        print('error')
        count+=1
! t5 q0 J7 }9 vfor循环
for count in range(3)  :
# J- T8 h  ?8 G+ k1 d) {    name = input('name: ')
  ]4 U  _0 W& O$ g/ V$ a3 n4 J: S' D; l    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. W" H9 [" f: J0 J8 w$ [        print('ok')
    else :
        print('error')
        count+=111、写代码
4 A; u6 G5 g+ H- \) S% ra. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
# ]3 U8 l1 I% _+ s9 }. n3 K6 R2 jnum=0
while count<=100 :
- ^) \6 y" e, c" s8 n    if count % 2 ==0 :
7 o4 K9 R2 W5 n  P, j+ [        num=count+num
        count+=1
    else:
; L/ v; @; Q- Y# j        num=num-count
& w+ W# o. Y+ }& w' b        count+=1
6 A! `2 Y7 i0 f0 X8 |; g5 Pprint(num)

6 V5 O$ ]  S4 O- x2 x. E8 ^; Kb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
/ @' J6 q# \$ d0 T; Z num=0
count=1
. e5 K& v9 a$ S7 s, p. Z' ^for count in range(100) :
. c9 M$ |2 v0 ~, y" K* Z    if count % 2 == 0 :
        num=num - count
& h2 ^0 K1 e! u$ V2 Y    else :
0 ]# W' T7 l2 w* i/ P0 \$ u" e        num=num+count
4 v3 R) O/ M6 z, ?! I+ U8 a9 F, Eprint(num)

c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12

5 ]! E; R% ?: T% o  n* f! ?! v: zcount=1
/ J9 F' X. G: W. _2 Wwhile count < 13 :
7 ^( y7 [( B/ h* @/ i/ e: b5 X7 ~( z    if count !=6 :
        if count !=10 :
9 _: t6 Y! C) p5 y            print(count)
. N* l- x0 ?# C9 c* f
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
0 f+ [  N6 y' e; w* B. L$ {0 s/ Q    if i %2 != 0 :
        print(i)
- s: Q4 u( w7 M3 p  c6 K
count=0
while count<100 :
  ]# S( B% C$ G. \- u    if count %2 != 0 :
: e) g, q$ s+ i, I; E, v9 J/ Y! X        print(count)
! @9 S4 G9 I& R- ?8 q4 n% m' U    count += 1
, N( B' C% @; C$ l. N( P
e. 使用 while 循环实现输出 1-100 内的所有偶数
6 V9 [% H1 V8 b7 {% d8 x5 `8 gfor i in range(100) :
    if i %2 == 0:
8 \" y- E  }8 ?5 ~0 `        print(i)

7 i8 c, ~% m6 p* Icount=0
while count<100 :
7 q! n, E/ p9 _    if count%2 == 0 :
& x: X# K- s0 ]0 E4 X# J2 r        print(count)
8 U& F2 f5 f7 H5 S    count+=1

" t( {6 `6 d. k1 D( a  }# g12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
" P. T9 B1 K2 `1 Oprint(oct(5))  八进制  0o5
6 X; S$ C& b% t  k14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
& c8 f. |5 f2 J17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
5 w$ H/ f2 \* M/ D0 Nprint(int.bit_length(n1))  结果  3

2 K8 ^/ e7 c! @+ W' y
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
% D: j7 O9 w8 V8 |4 J, c7 Y% U
5 h) ~0 P4 z& Eb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
/ p8 g. f1 f- [8 vprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
4 X$ |- m4 Z& [; ^, wprint(name.split('e'))   ['al', 'x  ']  列表

% ~: R+ d9 E- a2 Ig. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
) E. J+ {$ Y% m2 B
, ]) s* W; p/ E5 |3 u! y. Sj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
7 n. _' l3 A" ]" r" {. Aname = "Alex  "
. b% y+ J5 G2 v; e+ e. y: _) _for i in range(len(name)) :
    print(name)
, W4 m. L, [+ y  k/ o4 K! Nfor i in name:
: f  }  e9 t, Y# U( x    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
7 U9 V$ {5 w0 R( V% d8 w ['alex', 'eric', 'rain', 'seven']
  t! ]( _" Z$ m, ^' E/ Xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 T6 D9 v2 s6 \& a6 @# f' sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
6 q4 i5 q, l7 @print(li)
& L( ^0 C4 m3 {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
& f3 ^$ f( O* @li.pop(1)
3 A& F$ v, O" W3 tprint(li)    ['alex', 'rain']
; e5 ]0 A- g! ?% \, E* D指名道姓的删除li = ['alex', 'eric', 'rain']
/ y, }4 R* u9 U& wli.remove('alex')
print(li)
% [3 v' U, y( \: \, [2 _f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
, M, ?2 U$ {" R3 ~) Z7 ^print(li)

  K7 i, u' F& l( l( t. g/ Xeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: I7 c9 S; m; I5 I' a* E. Bdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
' x  ]8 b( A; R% s! Q: W' Z8 |    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  R, z* j5 z0 g( D+ Q3 f: qa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
9 u" c! h4 _8 z" Y' A24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
2 R, P0 [- ^4 i$ D5 Wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; f3 O% U# W" B! D- k% @( Iprint(len(tu))
5 z& ^; [( @. i2 U, b0 c2 {# db. 获取元组的第 2 个元素，并输出
print(tu[1])
7 H0 T4 K! M+ T0 a; }# L' R  E8 Ge. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
: ]  g" h3 {- j" ^- I0 `( M& j11 eric
12 rain
8 ^. d; |) s: A8 T' D: Q3 X
for k in enumerate(tu,10) :
    print(k)
7 O; g# ?7 }4 A# U; x(10, 'alex')
(11, 'eric')
(12, 'rain')
1 W$ o2 V2 ?  `  F

25、有如下变量，请实现要求的功能
' f5 T- ^4 D6 F  L7 M3 Wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
, Z* c3 U8 I3 O! d) g) N4 {    print(i)b. 请循环输出所有的 value
  ?" K6 F; m" C( `8 r* Jfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
! \& c, B1 k% ]: |print(i,dic)
9 i$ l% |% K) v3 p' B1 ?d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' Q2 S' t$ R; s( a, C# C/ L2 `dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 `& P  N3 \: M4 }' `; Y: u/ z) c; mdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
2 f1 N! G9 I/ ?* P" y& m9 o9 w. wprint(dic)
9 ]5 q' c; w: v- v. l) e
. e* Y$ L% l7 lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
/ w2 W$ z2 a+ \" T, x" A! [print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
" \( H5 K! {' u, |: h2 ^" r
3 l. H6 Y( e' J' v6 X9 @print(list(s))b. 将字符串 s = "alex" 转换成元祖
# R2 x& ^. ]; {& G' cs = "alex"
, A) r# k4 e$ b7 Jprint(tuple(s))

, e6 {# h  Q$ {  d& R! H2 ^6 M; xb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
5 `4 b" `2 z% S0 Nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; k4 e, Z% M- e7 R( E/ V1 @tu = ('Alex', "seven")
li=list(tu)
print(li)
8 Y6 \$ d! U& U* r  Q4 n, m$ z3 ]

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
) ?8 s/ L" c6 |$ ]6 z5 F# Wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: b5 }5 W, u0 C+ ^) T    dic[k]=v
    print(dic)27、转码n = "老男孩"
8 v. ]( k2 I, ya. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
: i' K9 ?, C: Q% Hprint(a)
b=a.decode('utf-8')
; g0 v; M& t" Gprint(b)
3 a4 h1 o$ I  V! M. ab. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
0 y. h! i" x4 f& bprint(a)
! s  g) C7 ]5 [$ g! T+ ?% Qb=a.decode('gbk')
$ }" s' C# L1 ^! Zprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
! e: i" O. g" T. ^    sum=sum+count
    count+=1
print(sum)
# r, k- w4 I9 w- ]
! S& H$ l! B! `/ W/ mcount=1
2 O2 |8 Y% D: v0 h% Q3 C! }sum=0
3 P1 Q1 C% j# p- |9 M0 @" ?: H! mwhile count<=100 :
% B4 \! I9 K/ k' f! b  x! z    sum+=count
0 h; V) n( C1 g- b4 h    count+=1
print(sum)29、元素分类
+ U* C5 r" u9 m' C有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
! T: c/ o3 M- n/ V4 P2 ]即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
+ S# J3 B: O3 V3 J7 ]# A1 udic1={
/ H4 P8 G# N- @3 z% a. E    'max':[],
# o* {+ y. q- E, b, l, V2 b, G    'min':[]
}
( h+ J7 ^; T6 f. {; x- mfor i in li :
! @+ v2 P6 y% E5 I. A: O    if i <66 :
        dic1['min'].append(i)
8 u0 Z$ Q' c8 c! G$ g0 _2 l    else:
9 u+ @2 I7 [; ]0 J6 H: J, m        dic1['max'].append(i)
) c& @) L2 l6 t( `  e# T4 k/ sprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}