Python基础知识汇总

1.执行脚本的两种方式

Python a.py     直接调用Python解释器执行文件

chomd +x a.py   ./a.py    #修改a.py文件的属性，为可执行，在用  ./  执行a.py 文件

2、简述位、字节的关系

1bytes=8bit  ,2**8=256,可以代表256中变化，

- W5 T- u$ C, I+ f" W3、简述 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
0 q/ U$ e  @* b2 D" |print(id(z))
+ O1 V% i8 E# o2 w8 @, I' A# h9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

8 P* j* M, b0 H0 M' E# E' {& P10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
6 a8 t  c# r/ e+ p1 ~* z3 n4 p2 pname=input('name:').strip()
* Q! h* w5 F* f6 r. A9 c, G) Epwd=input('pwd：').strip()
4 U; J- ~. U+ Jif name=='seven' and pwd=='123' :
    print('ok')
) A1 y: H, B" N8 {else:
. a+ L% \: N/ ]% |, E2 Q& I/ A    print('error')

% V! `1 c! v" }+ H5 gb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
) R0 F3 }* E# x8 G, I' rwhile count<=3 :
9 B; g  c. w6 l; Y+ @! Z' _" G/ f    name = input('name:').strip()
    pwd = input('pwd：').strip()
" q( z( E2 c! e' o5 y; W7 ~6 h
    if name=='seven' and pwd=='123' :
        print('ok')
5 y/ _! Z: `5 B9 k  k% Z: B    else:
        print('error')
% \2 n5 @  e' q, f9 ?        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
" y+ \0 r$ k( k    pwd = input('pwd：').strip()

# ?  e* R. M" y0 j8 R  P    if name=='seven' and pwd=='123' :
0 o! [: m! L4 d# e/ F6 h8 ]        print('ok')
# N# J; @5 m( v- v6 j) a: c4 G8 s  ~    else:
        print('error')
" u+ ]7 |( t+ C1 M2 Y        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
1 l9 l' T" I  z# p5 R- Ecount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
1 T+ W- B; Y# ]: f    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
9 M9 j% D8 u4 x. N# I3 p8 `        count+=1
  O6 o+ j* e; ^& {6 kfor循环
for count in range(3)  :
9 j# l0 t, y- x( [- q+ S    name = input('name: ')
1 S5 L7 C* T( B! l+ J    pwd = input('pwd: ')
* u9 |! i$ v9 ?& @# _# [& r    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 a2 M/ l# |' Z! P  I& b        print('ok')
    else :
& \$ p# O! g6 z* R        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
( |. X3 l3 g4 a& p; Fnum=0
2 ?. H0 q; R% ~, X4 p5 swhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
print(num)
1 w& Y, w3 r4 N6 z, r9 w8 l6 M" J: h- S
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
9 D- t0 S, T9 Y num=0
count=1
for count in range(100) :
5 L1 ^) p* `; c) K1 X1 Y: z/ ~2 S' J    if count % 2 == 0 :
        num=num - count
    else :
$ ^  v2 p( y( Y: U+ K        num=num+count
1 p% ~! C1 h$ F% Z8 V: y. x  q: x& @' T, xprint(num)

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

count=1
8 z: D( z$ ^+ ?: m/ qwhile count < 13 :
% m: i9 i, S" \$ Y4 a    if count !=6 :
; K1 X0 m6 N/ p( W        if count !=10 :
% s, g) Q& g, K# P: J. X9 J0 c            print(count)
. A1 N0 G0 A0 _  b) K2 u
# e7 S7 _6 l% \, U! Y- W4 g2 ]0 o    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
* P) T  v/ w, uwhile count<100 :
    if count %2 != 0 :
* L; B" C8 s! C7 R        print(count)
    count += 1
( b! r+ X' f. |6 }# j
e. 使用 while 循环实现输出 1-100 内的所有偶数
7 p! S8 r$ R; y0 hfor i in range(100) :
$ t1 ^4 H4 T3 q1 c' Z    if i %2 == 0:
        print(i)

count=0
while count<100 :
% _" ?4 \4 N" ^1 Z    if count%2 == 0 :
; e- j$ d, C- a$ e        print(count)
$ Q" r! S& F$ w2 t8 v& Z, u1 O1 J    count+=1

& M) Y, Y5 Q. ^4 P12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
9 h( _" h& ]: _" N! fprint(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

* V& N4 ]+ ^4 }3 m- O+ ]
, U* |) R' X  x' k$ i/ |18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
3 }, n! |2 i- _- j# i1 na. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
$ `. L& D/ T2 d
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
, ^3 T9 g+ n  i1 h  A6 A. Qprint(name.startswith('al'))
% u8 u7 v# S' M$ T) J( q# F, Bc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
6 f+ @. H1 @( n' y4 s' @print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
3 ]- O* f$ ^+ H+ a# oprint(name.split('e'))   ['al', 'x  ']  列表
5 P  \" ^9 B: \( z
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
5 u9 W8 G+ _5 A9 R
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
- Y4 o9 r; O# N: u0 {6 V3 u21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
4 |7 ^* t3 A0 Y) J$ O; Qname = "Alex  "
for i in range(len(name)) :
    print(name)
6 X* j* s. E& w6 m" {for 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']
, u# q1 q8 `) x8 L3 v6 Q2 T; Xprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
+ n  e& F7 X- [print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
' @/ T! m3 }  C* P+ cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 m9 ^9 F) b3 U! |" V8 R% T/ ~print(li)
9 {# c) @* O+ i9 U8 W7 Y! Ie. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
& j5 V  F" k% c) e, @- ^0 Lprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
# c' |4 Y) v; F- `5 T; zli.remove('alex')
print(li)
6 n2 q1 x( y  v2 y8 `f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
, Q  W! i" t: ~! `8 Yprint(li.pop(1))
$ n# I5 v+ C: p5 n% G9 r" P( Sprint(li)
( q" X( z# `3 i- g
eric
7 y# w7 q! o% J  u2 ~% V['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! w, d% E1 k" Q9 `del li[1:]
, s; T" E  S5 S* x+ j5 oprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
5 N. m, G2 `. x% V6 \    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% G$ N7 p( R* h+ }4 r! ]8 Sa. 请输出 “Kelly”
2 Y5 Y& K! V" n& N+ M! xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# ]; H+ Z9 U9 v  I; j, x+ H. C( |print(li[2][1][1])
- o) h; U  @1 V) ~b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
% c( g6 u' R8 b. L4 @print(li)
: \* Z: U5 M+ d% n9 e24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# {- ^: e8 k" C2 \a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
  q3 ^5 @! w0 s2 R; Pprint(len(tu))
b. 获取元组的第 2 个元素，并输出
3 r2 T3 Z2 ?- m" F, K% ]print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
1 N3 m' L5 b9 j5 m- \3 p9 qfor k,v in enumerate(tu,10) :
8 H# b9 S6 [, @0 ]7 Z3 ~    print(k,v)
10 alex
11 eric
12 rain

2 ?  j8 W. z* w1 r# \; _1 T4 a. Nfor k in enumerate(tu,10) :
    print(k)
' M) L# B, [1 \& u6 x5 ^0 x/ z* k(10, 'alex')
(11, 'eric')
9 I+ t. `8 [% F5 V0 q7 ~& q8 c(12, 'rain')


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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 z. L. B* P9 h, ^tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
$ }0 k5 J' h  F, E% i' N  T' A7 Ires=tu[1][2]['k2'].append('seven')

print(tu)
- m6 n, I$ D1 d) q9 O! Q26、字典
8 `( _; S3 R3 }. @dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
) |# x' |4 L$ a/ u+ `    print(i)b. 请循环输出所有的 value
for i in dic:
. f: ]' o. w. z    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
9 W0 p% v6 m5 W, }' L9 ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 C$ E' M0 C0 C. N! adic['k4']='v4'
5 T% k4 m  y( ^) H  x3 A6 bprint(dic)
3 s+ l- ~7 L. [9 Ce. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
9 _% u6 K9 U( D# d, p) ]8 m: odic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
% g2 D8 g$ v2 {" s. V# V, Idic['k3'].append(44)
print(dic)
2 l* }* k8 W* s/ I
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
: A* \- E$ w8 E8 f! _8 oprint(dic)
  U* a! n9 ?7 U: ]! |3 ~27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))

- O+ I  f7 J7 Vb. 将列表 li = ["alex", "seven"] 转换成元组
8 I6 ~7 Y* S" w3 Mli = ["alex", "seven"]
' B( k8 s  {7 ^5 B2 N& n% ]. mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
3 o- q$ S8 v: `1 [li=list(tu)
print(li)
% s, r& E* P, m- X  M, A0 v- s

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

' @# Z& D( Y  rdic={}
; a5 h. J; u' M: afor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) U+ T' Q* w2 t/ G# _a=n.encode('utf-8')   
: c3 R, s7 x, J: l. wprint(a)
* V) d& k5 m( m+ nb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- @' D9 s: N6 r1 }; v1 pprint(a)
+ O- @' M6 a  \* z+ jb=a.decode('gbk')
& V+ w2 m* J7 P+ @, q6 ^8 Mprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
1 P2 f$ ~' b# |7 f0 S    sum=sum+count
( Z  @. G5 \9 L$ Y" ^* @( r$ ]1 ~" ]    count+=1
print(sum)
, C4 h5 q: A4 M
$ y8 T1 i0 {* Q0 bcount=1
# l* c8 n- S  d2 f1 |sum=0
while count<=100 :
% A/ E4 Q2 Y* W  a) U3 b4 s    sum+=count
0 [  j8 N1 j' |0 }8 b9 J( z6 L/ S    count+=1
) Q+ M0 I2 D0 |6 H, N. [7 o  Tprint(sum)29、元素分类
' x4 Z3 q  x# K6 q3 D4 U$ y有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
9 v8 X- o% j4 L! U+ ddic1={
    'max':[],
    'min':[]
}
/ B" k7 k3 c8 v! G: u. z5 Sfor i in li :
! j2 Z" }0 ?1 M, F$ s2 L/ E    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
/ P$ I3 f# e, v, G$ Y+ h
6 e, @+ ~/ v3 n( g- _---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! {: ]6 y/ p* \: y