Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

8 v. x, n0 a9 a: c3 D5 r1 J  U3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

% R9 w% _- M9 k" e6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
4 D7 Q$ b/ q7 A4 D3 V9 _' O9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
; P* j6 C, e+ d/ V$ L) vname=input('name:').strip()
: m0 N5 t7 D9 C5 |+ }3 D$ W& F. \pwd=input('pwd：').strip()
4 a# y8 f' Q* |- e: B, N" \, mif name=='seven' and pwd=='123' :
  x) [6 z  S$ _    print('ok')
' Z1 {# r" I+ O2 pelse:
    print('error')

0 r5 P8 k( O# i. h5 B( Db.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
; ^" q  Z! F4 y4 I5 I7 x6 U1 O3 Scount=1
( L$ B! R# U# B' ^while count<=3 :
2 Q/ N% {( K! d4 y+ ]/ f    name = input('name:').strip()
% D( c% U) b( `8 N9 S    pwd = input('pwd：').strip()
  p# w3 r  {& J
0 m, b5 F9 W2 M( Y( ~    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
" Y1 D$ y( t& Z! y' Z# b1 G: n1 v        count += 1
for循环：
for count in range(3) :
; Z' r* c+ A# c; P1 Z/ D6 G1 a    name = input('name:').strip()
/ v+ `5 c5 l: r# P8 O1 f  o$ S    pwd = input('pwd：').strip()
8 k* E" T; w; l* g
, A' P' a7 Y8 A; b5 w2 X1 ], Y    if name=='seven' and pwd=='123' :
' S( L7 `6 S( k* Z        print('ok')
    else:
0 ]% R/ {& _1 {5 B3 A0 S% Q( E        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
: M& w0 n& o4 E# b    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
4 l5 o! U$ ~% U; t+ n- [2 w        print('error')
+ v6 _, y+ }2 P& `1 [5 Z        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
5 u- f1 Q6 j1 f# ]3 ]    pwd = input('pwd: ')
/ x% i$ J2 p* |: h0 E* b    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 \/ g% r& h# l4 l; C        print('ok')
    else :
3 O# {9 H; z) l( z' ~# {        print('error')
        count+=111、写代码
3 h6 ^/ \! q% [( Ba. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
% ?: i) V! ~! vnum=0
while count<=100 :
9 V% I( L& v4 ]* M1 J5 @    if count % 2 ==0 :
5 T/ I3 f; J) v+ |# _( p6 P        num=count+num
        count+=1
    else:
        num=num-count
* ~! }- [( w, l9 B9 C& X6 D        count+=1
print(num)

: t% {. W5 A" H7 a4 M4 j: r$ Yb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
% `) S9 y; v+ H8 B, {& p    if count % 2 == 0 :
" `. \; T, z( v        num=num - count
3 L. B5 |) R/ i; v: V    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 :
$ z9 W& O2 D* U+ f  C9 w. B3 P6 E        if count !=10 :
0 |$ u; h  _* F$ P$ \            print(count)
) K& Q3 q- U& X& ]6 a
. n/ A, L0 o, a1 w0 V    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
+ _  o6 z+ |7 Q  }" p- S) v* Y    if i %2 != 0 :
' H* n% R+ q9 |        print(i)
* C7 U3 s5 G' C8 y
* R' R4 e6 O+ Y* f/ |' bcount=0
% g. t4 M4 p! {. `6 ?while count<100 :
    if count %2 != 0 :
# J# h( E; G% l9 C5 S  a6 \9 P        print(count)
    count += 1
% A, h3 M! _$ ^1 b/ V" m% J
0 J+ D# z  S& a7 Q3 U; Q0 X" S. ve. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)

count=0
1 b2 \, k/ |; d+ K* V7 J+ bwhile count<100 :
8 K  k9 E: K+ h, H, O0 _    if count%2 == 0 :
  q  m$ w, z. a        print(count)
1 y/ W8 h; @$ f    count+=1
0 N! P1 v" H) s
  {; R: a5 R; W9 N12、分别书写数字 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是连个不同的变量名，但值都一样，都指向了同一个内存地址，

7 o( C0 d% e( p0 q+ D16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
& L( ~. F2 [6 j& M17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
1 [2 t( _$ V3 T. L, ]& {4 U1 ]print(int.bit_length(n1))  结果  3

; j. J* o$ l( }) f' K
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
1 D# m3 a8 ^. x6 e6 R1 xc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
% @3 _! ]8 D. B1 S% P4 y" f: {e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
6 j' d9 M+ E$ H3 ]) |5 aprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
' R* F# z( B9 Y/ ?; B
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
8 o0 g8 ~4 }& _5 C21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
  I% }# a% L0 f" cname = "Alex  "
for i in range(len(name)) :
    print(name)
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']
% @! S  [) T& T2 s9 ~/ c/ `print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
& q- l, ^% \# n ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 P6 z# U# C0 H0 A, v7 @print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
2 [/ T; ]6 R9 R* X% U$ q9 Yli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
6 b- M) Q* B/ K: e- [# _7 [* Wprint(li)
0 w% B# v1 `+ nf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( J0 j/ o5 o$ n: [print(li.pop(1))
print(li)
: j. z& P% b- n* `" ^: W- q
; L- |7 l4 n2 Peric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
, u6 N" G/ y- e4 `7 ]print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
, z* w5 I, m+ Q3 }* N0 c3 e8 @for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
3 B8 D3 M# |9 C+ n/ |# _li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 }- L' [5 v$ N+ N! wprint(li[2][1][1])
1 `# F6 n. ]+ I' H, o: Fb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  `& Y: k2 [: q3 tli[2][2]='ALL'
, J2 ]7 [! d, y' f. Dprint(li)
# }8 J% j) J6 y. D( o0 p8 l( p24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- G% K3 d5 s4 }3 _! `a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
( n! V: S: b$ O6 f; M) P, }3 J- Eprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
( x4 o9 H! e1 w7 n5 m# pe. 请使用 for、len、range 输出元组的索引
* O' z% [; T: E0 t4 xfor i in range(len(tu)) :
4 I9 n, g1 e  P" n    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: a1 W0 y& H* ufor k,v in enumerate(tu,10) :
6 q3 k8 B/ }! @: a6 T    print(k,v)
# O5 z# l# t, D8 q10 alex
3 J) b- ^5 b1 I8 `+ F( W, o# Q9 Z0 i* L11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
- `& f) N% c0 m( n/ T(11, 'eric')
; }3 T9 w" ]) d. x' |- @(12, 'rain')

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

元组，不可以

- S; W: M: {5 e: h, gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 u, W# A1 C, }, Zres=tu[1][2]['k2'].append('seven')

print(tu)
3 z0 A! O* Y- p- E! X% Z26、字典
6 {% T# j  g: K# b' i: c/ \2 f: ^" w% ~dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# q( k3 d. g! m6 ]+ M    print(i)b. 请循环输出所有的 value
for i in dic:
; k4 B0 N3 R7 \$ M    print(dic)
7 s# q3 B7 m" B# L: N" ?c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
4 F; V( {0 X( P3 cprint(dic)
" t( e) P& X' B; F& Se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
4 |  {: \# K0 _  M: Y  \- |* P
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; N6 x' r* f+ N6 B" D; wdic['k3'].insert(0,44)
4 C$ d7 d4 k/ ^9 ~+ n8 i3 E7 iprint(dic)
27、转换
& e; Y- u6 p4 i  Q7 @- w3 Sa. 将字符串 s = "alex" 转换成列表  s = "alex"
1 ~. a9 M8 ?# i; P* R
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 l" [0 K6 b) @& e$ f% bs = "alex"
print(tuple(s))

8 X! o; x2 R- F! _1 {5 {8 Vb. 将列表 li = ["alex", "seven"] 转换成元组
3 p+ Q, S# V  Q: B  Vli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
' V+ j( {0 M4 z
; Q: l5 |: ~$ E' ^
# z+ h/ t$ g+ [% m* R( ad. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 T) u) m4 [) f+ L
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
% M9 \. r- y- Y; I' H0 H) h    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
% Z- ^2 J% n% o4 vprint(b)28、求 1-100 内的所有数的和
" f$ S6 t2 _# e. k8 c, E$ t2 _count=1
sum=0
for i in range(100) :
5 N$ R7 B* a: ?* G    sum=sum+count
* ^: E0 E1 b0 M, t! {2 A8 }: W4 Y; h$ s5 Y    count+=1
print(sum)

; \. b$ S1 H+ I. v6 z, E9 \9 x; kcount=1
sum=0
while count<=100 :
: c8 n# E0 F) x    sum+=count
5 a1 X2 I" Z5 q7 @9 r+ D% I; R" e    count+=1
print(sum)29、元素分类
有如下值集合 [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]
8 u. P) O* V" ^3 T# Zdic1={
    'max':[],
3 X! R6 F) m- K    'min':[]
* ^+ I0 m/ s7 S}
+ l. J9 ^- G8 v6 W* _1 vfor i in li :
    if i <66 :
  q2 A! ?) f" l6 {- D        dic1['min'].append(i)
- h* ]  I2 B2 M    else:
, S% X9 s0 p6 F# q! g        dic1['max'].append(i)
print(dic1)
3 r* C! u2 ?7 W( [5 J8 F
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! X" X! ?  C6 t) t+ p; F6 E% j0 J0 u" H0 E