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

. H1 D9 r# w& T! u5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

4 z1 }; Z" s7 J$ E* f; y6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
7 a: \6 N) `. m. Q( U4 K: U* }% tprint(id(z))
; Z9 t& w' l4 g2 t) l9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

2 }* Y0 n0 K5 m' K' l' U10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
  ^* ~% S8 B! ^name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
& `+ q: l0 {! X" W, r" }else:
' i$ W2 S1 n' `4 W5 g+ l    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
, S+ z; r4 i6 T5 n* D$ Kwhile count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

$ c5 ?7 h* W- z! k- ~2 Z3 V    if name=='seven' and pwd=='123' :
        print('ok')
    else:
( M( D( a& c0 ?        print('error')
& U8 w- l: Z5 Z        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
# _( [* O! t2 Q& o    pwd = input('pwd：').strip()

% I: [6 o7 j+ ]( n3 P    if name=='seven' and pwd=='123' :
        print('ok')
6 G0 U- \9 Q  r$ W- @" V, T    else:
        print('error')
9 E9 A/ |0 l* c' p. T7 `        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
, a+ z+ ?' u) F1 K6 |count =1
while count<=3 :
    name = input('name: ')
8 h' m: Z  G5 X) c$ h    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 |) ]1 K% c: o9 g- p: T        print('ok')
    else :
/ n# x8 c; P: O* Q9 t$ G6 X0 J! B( p        print('error')
% ^" G# i- O9 T& t        count+=1
' G9 @* G# }" q5 A6 ^  D8 Lfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
" R* Q; ?' E# o- v2 v    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 e1 t( m( X0 ~- B; a( q        print('ok')
4 u. o. ~6 n2 ], o7 O1 f  d5 P    else :
        print('error')
9 c+ m' k; f3 u9 [4 r        count+=111、写代码
* W9 _* ?" T  Da. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
# x: S. p/ }  ~# D+ a4 |( qnum=0
5 j" n& u+ F4 J& M- t- s+ `while count<=100 :
    if count % 2 ==0 :
2 i$ T& s: E& h4 i2 @' g! d/ A        num=count+num
) |1 y8 w( x5 I& |0 B+ M        count+=1
# K0 u3 N6 Y- u$ }    else:
        num=num-count
        count+=1
6 P+ q) A9 P' X# c2 w% W+ Jprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
: p5 |( z; U1 e) O) |% x. f: zfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
* O  K$ @4 B! m  p1 E, u+ d- L        num=num+count
1 P7 k  A: d2 e5 [/ oprint(num)

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

count=1
while count < 13 :
- s" C+ ^$ n; f  W- v8 m- K    if count !=6 :
5 T6 m& w  E: _6 A$ K        if count !=10 :
  h0 x* G1 k, ~- w3 I% ?2 w            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
% k% g+ Q" _# [# U, x    if i %2 != 0 :
. ^( O9 X3 J% n        print(i)
( @* k7 A2 R1 O8 J
, b( s# @% x1 O0 ~" C7 ^$ P- Gcount=0
while count<100 :
4 H( B7 [* c. d; [- R' r9 I    if count %2 != 0 :
        print(count)
1 V4 R9 Z+ r( ~* _: T) w3 d    count += 1

$ h1 c# U! z4 [( X7 ee. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
0 D  W) W" G: s+ C5 v) S' w' C    if i %2 == 0:
        print(i)
( t5 G% e3 R' S5 Z1 J  g" U
5 }3 E) P( m- _& lcount=0
4 ~  w; K) B3 B% A% ^while count<100 :
& T5 \9 R& A2 Z) p; B    if count%2 == 0 :
        print(count)
9 T; A4 N+ Z& S# |, M- F    count+=1
/ g7 ^1 L* m' V" _: V
; ~  x; ]) X4 K& h12、分别书写数字 5，10，32，7 的二进制表示

, r" A7 C4 S% `% m' z1 \print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
9 `; K; \2 B4 g" s. t  B/ yprint(oct(5))  八进制  0o5
! C- n4 j! v& H+ s! o, s- w# q% [4 m14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
) }% @5 B$ p5 s+ e. L$ U0 g; I2 A! @print(int.bit_length(n1))  结果  3

5 B8 o+ F' a2 o) d9 B8 v$ |18、布尔值分别有什么?

False .Ture ,或1  和0

1 Y' V- Z- G- Z# u8 A20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
( k, V: T+ G/ x: c" {7 ea. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
8 y- f  r5 d; V) U( I4 B, i0 I1 D( X; ^print(name.startswith('al'))
9 w8 Y4 Q5 T/ w6 V0 {" sc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
8 f! C0 z: \& ?0 K$ L( y" G* P( aprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

8 ?' n& g  s6 T/ w" J& w2 G6 |$ z4 |g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
( g. ?' n' e" p; X' ^1 n8 N
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
$ \- j3 N0 }9 ?4 Q: Jname = "Alex  "
for i in range(len(name)) :
    print(name)
! w( T/ x: Q$ T" l8 T, c% xfor i in name:
    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')      
3 K; n/ m3 K: W" ]print(li)
['alex', 'eric', 'rain', 'seven']
6 I. M0 v5 X& V# @5 \+ H5 \c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# D9 {; O6 F; {; s. mprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
, V& r6 D8 N8 C, _1 sprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
# T+ Q# _+ K% Z7 M. I" Z& ~$ Xf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
1 P$ B  I+ ?& l0 qprint(li)
2 h- w- X* y/ D8 w' D
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) h. _6 p4 `) y. j- Sdel li[1:]
. J/ [* o( [8 v% y/ g& u$ }+ Xprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
: E# U% z" I* n# m& ~li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
; A- _$ w! I& g/ ^: y    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ f' ?. O5 V3 S( I# s8 ia. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% h" I0 \; |% dprint(li[2][1][1])
5 V# c% q& N0 e- p/ N9 Ub. 请使用索引找到 'all' 元素并将其修改为 “ALL”
/ y% W3 p7 r* ?li[2][2]='ALL'
* n% F6 ]1 S  }: J5 Z( tprint(li)
% t7 ^' \3 q- s( s24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ [+ i6 h5 p' W  M5 i1 I7 h0 @4 iprint(len(tu))
b. 获取元组的第 2 个元素，并输出
8 u  B3 i' d: H* m' L0 ]& ]' Y. Gprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
4 q, _+ u* P" @3 s* u$ D    print(k,v)
10 alex
. {" l. h! M& D4 k  d) J11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')

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

元组，不可以

' C7 ^& a; J4 {0 L: dd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ U+ M" }$ u- H: d1 Jres=tu[1][2]['k2'].append('seven')

print(tu)
, k# ]( k' h* p. n2 Y% y* Q26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% F9 m- w1 C& g( J6 Y& Z    print(i)b. 请循环输出所有的 value
for i in dic:
! p1 o2 y  K" p9 t4 b    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
2 G8 l2 M6 x6 s8 p3 `" j- {d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
- h) H/ k: h4 ^; P9 H3 ~print(dic)
0 o5 @6 y, I) d. me. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* c- O: D( v# a! e% G. Kdic['k3'].append(44)
9 p5 T& y3 _7 h- e5 c! {print(dic)
- n$ e! H, s  h& [6 \/ F
$ a$ t0 P( t1 h. Ag. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* \0 e+ g, h$ t% Fdic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
# `, \  i2 I& f# D* I" [
  L) h" U. e& `# |$ mprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
% b& P$ f% G* J, s  ^3 H: kprint(tuple(s))
' L# s* _, g* h6 i
* s; _- e2 `1 W5 o0 I0 Tb. 将列表 li = ["alex", "seven"] 转换成元组
& _! [% \7 d$ B6 K2 J+ Q( p2 a5 Nli = ["alex", "seven"]
6 A' L5 f/ c- B% d. o0 C/ Iprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 ^% E4 ?. p+ M# g" s. ^- P- R0 otu = ('Alex', "seven")
li=list(tu)
print(li)
7 }: f" J3 g# q6 u) B' z

! b! p3 v3 p' b4 t3 N, nd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
3 T" i) n* t( h, ^1 E1 Bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
/ s( p5 P7 Z/ v3 B$ v( @% Z  n    print(dic)27、转码n = "老男孩"
: B2 c3 C6 U6 Ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
0 P$ @0 Z6 m1 R$ j8 ?a=n.encode('utf-8')   
5 a! K9 T; y; k7 Yprint(a)
8 d: [6 M) s8 B# M; |+ Ob=a.decode('utf-8')
3 r( W7 O0 E" T/ ]/ I& n5 oprint(b)
$ k9 y7 t. D$ Q4 `5 f, G1 t- @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
1 K0 b  m5 ?- n5 M3 _b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
0 `% }! `% @3 r, x    count+=1
( A# r! q! l% Tprint(sum)

% `! B+ O7 _  n/ l* m+ @2 i6 Vcount=1
sum=0
, [3 w6 ^1 x/ \2 k- i& o2 j; ywhile count<=100 :
8 B/ }- ?7 }* U1 n    sum+=count
4 R+ ~. b: V% U& t- V1 N4 p+ f    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 A* E7 n! N9 X: w. I% O% N将小于 66 的值保存至第二个 key 的值中。
8 i5 c- x# h( r: z) H即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
: w/ x+ A9 ]8 yli=[11,22,33,44,55,66,77,88,99,90]
: K  i* S/ _$ |$ S' r* b' P$ gdic1={
    'max':[],
    'min':[]
( l, p' {; L' O. |* M5 Y9 O}
0 z( C3 V2 Y" q" ofor i in li :
) Z- K! r# p! x) I6 E    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
  b! F/ v" j  o
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}