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个字节代表一个字符，

3 {' H- W" V- i) f( o) K0 _' Q2 U* J4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

# b# s* m% G1 J0 @/ C6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
8 T* z% ?, j4 X) G* R! E$ F+ i, Oprint(id(z))
, \* S7 o# h! ?& [% X9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

8 [$ Y0 h, ?# p6 w; {10、写代码
. x% p% @+ b4 D, `. |; l8 @a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
6 C) h. f9 X/ Q7 Opwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
$ Y$ m0 Q" x+ a$ j. ]    print('ok')
else:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
4 G1 J! C) ^: ^+ Z6 p( H/ [count=1
while count<=3 :
6 D$ c, t$ `& t' l# m' B    name = input('name:').strip()
    pwd = input('pwd：').strip()

" ~5 h$ a# x" Q, j( C; q! j    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
5 N8 D# {# M! _  F    name = input('name:').strip()
5 ]' y6 U6 g+ ^) W6 a. p7 z    pwd = input('pwd：').strip()
# u) B0 A$ L) {6 |: G
' c" Z8 y0 A" N9 ?) ?6 I    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
/ s3 i% ]+ T; N' F0 @while count<=3 :
8 q5 e; m, E" M9 V8 Y3 u4 C    name = input('name: ')
7 i; z2 G0 S& \- |% M! H, s9 ^    pwd = input('pwd: ')
' b% P' r* B( \    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
. V5 H3 J3 W* y" L& v+ f        print('error')
        count+=1
for循环
for count in range(3)  :
4 t5 R5 |$ w, w. j    name = input('name: ')
- f  l# Q5 f8 ]' ?    pwd = input('pwd: ')
6 x5 \4 M2 [# G    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 q1 n) _  i- z" Z% g1 P        print('ok')
; b. ?2 z1 I# _' U/ C" }    else :
        print('error')
( N) _- T5 M$ c1 M9 F: Q        count+=111、写代码
" O. X$ J) x# q3 @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
$ E  Z8 h' B. K7 oprint(num)
' S% |' R" H; }; @5 ~+ s  w: y
' P, I. ~5 R/ U* _% |2 }# q. x3 Q4 sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
* {8 [9 W, \; Y5 vfor count in range(100) :
' w- h! x) G' ^% i# I0 K1 y& i% v4 R    if count % 2 == 0 :
        num=num - count
- x, S7 w: D3 a- r. ~+ A    else :
        num=num+count
print(num)

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

7 a) X# [1 I1 G( C, Gcount=1
! N: J% W, }7 W' D" mwhile count < 13 :
    if count !=6 :
: @& @4 \; V9 }' {* c        if count !=10 :
) g% M$ z2 z: e$ X; o+ t& f            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

! S4 d) E  e5 e  H  l9 f+ ycount=0
9 Q6 k" k0 i0 k! ^while count<100 :
3 _% b3 v+ v( Q4 D  ^- H    if count %2 != 0 :
        print(count)
    count += 1
" n) R" c4 r1 k) @! j
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! O' T, ]4 F4 Z( u- W' O+ D5 x    if i %2 == 0:
        print(i)

3 D" ~6 L. |3 f: d3 C: a& M6 I& Dcount=0
while count<100 :
    if count%2 == 0 :
. m6 b8 R6 e# t        print(count)
; M! A6 X- }8 L    count+=1

" J4 F3 z  J, _! T/ ?12、分别书写数字 5，10，32，7 的二进制表示
8 p: D5 t- t" J  ]4 b) t, u
" @+ P7 R' k; v) |$ @print(bin(5))二进制   0b101
" A1 z" p1 \' R$ tprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
8 O0 I' p# R% i% j' g/ h- R$ Q7 u14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
+ s3 ?6 j9 o, C6 Q: P6 r) ?print(int.bit_length(n1))  结果  3

, L9 c+ D: d. z7 t+ W7 \% g& U
18、布尔值分别有什么?

False .Ture ,或1  和0

% U' b' {/ i) h0 Y/ i& m20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
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  
4 {5 c3 ?1 }8 l5 Q" ye. 将 name 变量对应的值根据 “l” 分割，并输出结果。
$ o% }: y& u) m4 m, }$ \5 v7 H5 }print(name.split('e'))   ['al', 'x  ']  列表

; Q& j3 _' Z4 wg. 将 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'))
/ s6 f1 Y+ A+ G- b: t8 Z0 s/ t  l21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
2 Z: q% X) u. O# o) i    print(name)
! ?- X5 j/ t0 \/ L6 c& c  w" ^for i in name:
: G8 U. Y9 X) t# o! [    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
6 ]0 ^1 M7 g3 e22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
# F! a7 h3 \+ G0 J% W% A; A" fprint(li)
['alex', 'eric', 'rain', 'seven']
. ~) B* Z( U( Z7 t' ]# e; ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 }, ]; S, Y. t5 T+ Nprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
! A* n7 X% v! O, m: c% e0 hprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
, x: b+ c' U/ j* i7 ?li.remove('alex')
print(li)
1 y4 q) b0 m, V! O8 S! cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
$ T- h. j0 n2 uprint(li)

6 M: `$ c7 D7 Y  B2 Keric
2 Q! E3 d) l7 [. E* }['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
: M. q: _8 q6 R' P5 G. r% N# y$ wli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
- }* j' i- @7 Q  _* ~) j    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 t* S9 e3 h+ Ua. 请输出 “Kelly”
6 v7 L- q, W4 x& n4 {3 Q' sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
) m8 J9 l! e1 ~* {li[2][2]='ALL'
  [1 t. h! z- L9 c5 Vprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
- Y9 m$ M* [9 p8 z. `# L/ sfor i in range(len(tu)) :
/ G- c+ o% i: w6 z* n4 `2 v    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
9 D( ^& b) H3 o/ C) S$ zfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
) n9 ?5 I- ~* ?+ [9 p5 z, y2 ^! j# I+ j11 eric
& @, L2 L% l$ v0 A0 B12 rain

8 G5 b3 G0 C( i2 J" P) Y3 Z; c. S) Gfor k in enumerate(tu,10) :
5 }6 k: R2 S1 a+ t' f    print(k)
+ s: Q: g: w: s7 g6 ?; {(10, 'alex')
(11, 'eric')
(12, 'rain')
! n2 K0 w, H5 q- u5 d
! A/ w9 d. \4 ?. o. G3 d# N1 }
# q# R3 t: [% `$ w; {% s& r/ J4 ^25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
2 f9 p* U9 s3 G- O; Xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. W9 a$ ~# o0 o7 s' Hres=tu[1][2]['k2'].append('seven')
1 o9 T% E% @* C
  @  q; I$ g. ^& h' wprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% J2 b7 e) p  t    print(i)b. 请循环输出所有的 value
for i in dic:
$ }7 \: @+ [0 ?    print(dic)
* G8 Y) \% P" X0 ?6 a- G( s% I/ ]c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
3 K" f* p6 A0 Y* j3 A3 u; Cdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
3 r9 [/ K: f1 S& _6 `5 P
7 q7 `* y) f- }) r/ [3 F  yg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
+ }& K6 J+ _# C  ?8 [print(dic)
( u9 n. z2 ^- r' N- n7 Q- ]* W27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
9 p9 q/ J  L! g2 ?( Zprint(tuple(s))

  g# z8 z$ N$ j( y  h: Vb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
, E! ~4 w4 R+ a5 X' Eli=list(tu)
& S% A2 A: B, C, Y5 g  e5 u) uprint(li)
8 }. z. \7 p7 S' M$ t
$ V: i# M  \5 x0 Z5 F: x
7 |4 s9 P& ^: ?6 I7 {d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
! \7 r" ~! l1 F) a
1 j7 E. [) T2 X1 fdic={}
* y) ~( z7 J3 V6 Y. d) gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
1 U9 U6 _- B4 L    dic[k]=v
) ?7 M7 v2 q! o6 _7 D    print(dic)27、转码n = "老男孩"
. c' B" y, H! @0 a6 \9 s" y1 }a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 w4 J% G+ H& Y& c, h9 |a=n.encode('utf-8')   
print(a)
0 j! O2 n5 w4 [* W; i2 L$ J/ gb=a.decode('utf-8')
) ~2 ~/ z$ i) j* [print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
6 d* S7 D" `& |3 T1 Z  _+ B# D: \count=1
& B9 ~6 K1 V5 Xsum=0
for i in range(100) :
    sum=sum+count
6 {% x/ E- b$ L7 q* ?* E6 V( z    count+=1
print(sum)

# y, M3 x! [+ y0 @4 X7 _- V& m; Lcount=1
sum=0
while count<=100 :
& ^( T) O9 d* I* Y  b( x    sum+=count
    count+=1
2 c& l( }9 j  s- ~+ C+ nprint(sum)29、元素分类
6 O$ p5 P8 B: m% J8 S1 \  X$ E有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: D; a. S) ?2 ^# ^4 K) m将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
1 c* Y( \$ g! z0 I    'min':[]
}
9 ?8 D* \+ R6 T9 W* m0 b9 zfor i in li :
' Q4 t: Y1 T0 D& D; V) H% s    if i <66 :
8 O7 c% F# K7 S0 K* }  u        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
6 m: q" s/ Y  @2 U$ h( m  xprint(dic1)
9 z" a2 b7 n& u% f9 t9 K/ p, p, |7 S
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}