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

单行注释  #

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

6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
5 i4 j8 P& R+ U7 Y$ {1 T  Ez=1
9 b; j, }1 D6 C6 m, L  pprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

' P& u( P- O- |# m! \6 p2 x" d10、写代码
4 O2 U% }! `3 a0 Ga.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
" R. d) y$ I" o9 y, Sname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
2 D7 e; p/ h1 ?* G( ^3 A
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
$ {7 u, U% r# Y! M2 A- ^    name = input('name:').strip()
; x' h* Z' H+ R7 a6 S    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
& e- l1 h! W4 B& H        print('ok')
( T# [3 q1 E, a    else:
        print('error')
6 k1 `7 t, S5 f7 d        count += 1
/ Q0 c! `4 q  efor循环：
for count in range(3) :
    name = input('name:').strip()
0 w8 ?0 Z) ^8 U% ~    pwd = input('pwd：').strip()
! R0 G8 P) q9 [0 K; Q
    if name=='seven' and pwd=='123' :
, b1 l, E* V% C        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
& G- q" B0 K0 y& ]while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
  F; ~* l( S0 F% Q, }4 P( l- ?    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 ]5 D  ~8 X  F, b( P6 H' D( \" |        print('ok')
1 j# L8 x' R$ a6 h    else :
        print('error')
3 t6 l! ^3 n  w7 R4 _1 L        count+=1
for循环
7 t: y* p2 x- V" c. ~/ Kfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
# Z0 a6 t0 o6 ]; {! c& z    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 A: N; \! l0 x  N! ~        print('ok')
    else :
        print('error')
        count+=111、写代码
; t9 r" `- k6 q& r+ {a. 使用while循环实现输出2-3+4-5+6...+100 的和
) `; I3 E( B& {count=2
num=0
! M* a7 O/ N* ^5 Pwhile count<=100 :
    if count % 2 ==0 :
" u. g4 i9 A! a5 x        num=count+num
        count+=1
    else:
; M( v6 Z8 ~, F6 {! Q. V        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
* _( D6 J1 C- _3 ~: w1 T  X8 W num=0
count=1
9 g+ |3 S7 l4 Q7 K8 w; Dfor count in range(100) :
    if count % 2 == 0 :
: l, }" w+ ?$ b& Z        num=num - count
' w5 O- y' A& d3 ~9 F4 y    else :
        num=num+count
7 o9 d9 @8 D& W. q- Zprint(num)

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

count=1
! `" h6 ?0 i) N7 `( h) ?  V2 zwhile count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

2 A4 B" Y8 H9 \$ @: p    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
0 T3 K+ ~5 `& y6 k- }$ Xfor i in range(101) :
- A& y/ j% |3 R2 l    if i %2 != 0 :
8 o! ]" ^+ q9 N7 Z        print(i)

& t3 X; L/ J1 Z' w0 ocount=0
9 _9 _# b, T2 `  C2 x* Dwhile count<100 :
7 p! |. O8 z3 f. ]0 A( R    if count %2 != 0 :
        print(count)
: c2 I- N2 Q5 d    count += 1

* N) m2 V8 N+ q1 T$ U# ~4 z4 A& T0 je. 使用 while 循环实现输出 1-100 内的所有偶数
' l+ e6 v" _- yfor i in range(100) :
    if i %2 == 0:
0 }: p* B& B4 l8 e7 H        print(i)
% K  ~0 v7 T1 w2 f
9 e) P! z. W$ H/ r: e6 y. u5 M- V$ Fcount=0
while count<100 :
5 H4 U* z- H: @/ X3 q. v# V    if count%2 == 0 :
% l7 k) |1 g, Y' {. n        print(count)
! {, z8 [0 s* t6 Q# z    count+=1
9 k$ n0 N1 [3 p
9 S" r# P" S5 N- R5 W& n' |1 _! I12、分别书写数字 5，10，32，7 的二进制表示

& Q+ Q# B; c5 A: l" Sprint(bin(5))二进制   0b101
6 H) @5 V( l4 V3 a% Lprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
9 P# i( |  X$ N- L" Z4 f14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
print(int.bit_length(n1))  结果  3

" L0 O: F0 B1 V  F$ R: A2 H# {
18、布尔值分别有什么?

False .Ture ,或1  和0

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

' G6 D- K/ X; E; c3 X; H  rb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
3 b* R5 I' j: A. w6 ~, T$ {print(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
2 ?. g( p, D" }$ w/ q( G9 [
1 f1 |% I' J+ ]& _# g- j! [, H3 @j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
; r* o% C$ W4 V0 B, F& v' ]2 D21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
% H4 r, O6 T1 W' @5 p' ?依赖索引
name = "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']
, N$ v, f) p3 _5 V, Bprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
8 |0 p+ q  v$ i/ M, Vprint(li)
$ g+ N6 U3 a& h3 Y ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
/ W8 `. }" Q" B" G7 M6 q2 A4 uli.pop(1)
print(li)    ['alex', 'rain']
" R& V; d% e' r& B3 e* ?指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
: n9 [8 ?" W# r/ O) hprint(li)
2 N& J* d3 e& x7 p) O9 o: A0 ^/ Vf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ N5 A  G7 Q, R* I6 D. mprint(li.pop(1))
7 n. {* n  `( J6 {8 Qprint(li)
2 S0 K* m. d0 S+ g% x6 Z
# _2 S6 {, z" R7 T7 f3 |eric
, J8 i4 o+ ^: m% B; `$ \  f. _' ?['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! c, }! P' V3 m3 Kdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" ?+ y3 t: g, t% r- ]+ Gli = ['alex', 'eric', 'rain']
  N* D! V& s, M" T/ ^for k,v in enumerate(li,1):
& c, c' o5 f7 W; H8 W1 ]    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, m* t7 C7 |& X" b' w8 ^' t/ d0 Na. 请输出 “Kelly”
% C2 ~( k2 q) p* a6 Y5 X( D3 A) Qli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 J+ B6 V- F( ~6 L! v( aprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ A# l4 M. t4 s; ^+ f3 Vprint(len(tu))
- c3 `; W+ _" x* M0 y1 Bb. 获取元组的第 2 个元素，并输出
4 ^/ K% L- A& ]: j3 p6 F( Nprint(tu[1])
$ d5 L! z# p4 ^1 _- Ee. 请使用 for、len、range 输出元组的索引
4 `! A, n+ V  M, R: sfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
' f5 E9 a9 g, y: V" C/ S$ C( m    print(k,v)
; j; r$ b9 W$ K' ~10 alex
11 eric
12 rain

9 t) {# w. b) xfor k in enumerate(tu,10) :
7 i( v' g  H, ]/ O2 |0 }    print(k)
(10, 'alex')
7 P# V- v* l4 r8 U) }(11, 'eric')
7 U/ H9 \' D( l0 K& R- R/ \(12, 'rain')
$ y; b. E: l9 t, C3 I
/ V, R: |7 _8 D
( n5 C! o; V2 \9 D! h25、有如下变量，请实现要求的功能
" M5 d! d* q: c0 k* Dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

2 Y$ m# B  |" b% m% y1 O$ `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')
& \' E. ~; I  U5 x+ ^5 p+ M
print(tu)
4 J. x$ O# C( P7 P& M1 }26、字典
  _' U2 s. h) `8 l% m, q9 O7 vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 f1 z% ^6 Q3 L. \- [: n" z    print(i)b. 请循环输出所有的 value
6 J2 z7 l" U# g( D. ofor i in dic:
. o! E& f9 }; M  R) R: _    print(dic)
4 z, g3 k: T2 }. Rc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 Y4 ?! |3 `$ {1 p" f  q1 hdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 i! |$ A2 S! c6 a: O0 J4 N( e+ `. Kdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
8 F" ]: r) K2 [  qdic['k3'].append(44)
" s- h4 Z; `- qprint(dic)

7 H+ u6 j  s# a' W3 g: U& _# Wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
' O+ t2 m/ C6 W1 Kprint(dic)
0 ?% K& o9 [0 w& f' n27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- {* f* k/ ~/ U" w" I
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
, s! [8 ]$ b1 q1 o
9 m0 P3 L: ~2 g3 u8 r0 n! Sb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; s4 t& R* ?) ?" Otu = ('Alex', "seven")
li=list(tu)
print(li)

# Z  O+ [5 W- `7 j
- p/ p- O. Z% sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. J. O" C; W2 S3 S" ^# B    dic[k]=v
  B$ I. X* m' r2 Y; j3 x( A    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
0 T& H# Q) ^1 S* K2 Lprint(b)
3 V. O  I9 S+ g+ m9 o3 q6 [b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
# h3 d- H; R# w  lprint(a)
b=a.decode('gbk')
- X4 N1 p9 }1 y# h* Lprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
; |7 e- s3 O' s( Y, R8 _% A    count+=1
# b9 T% v( g. O) c1 i( q+ l6 ]3 ^print(sum)
$ p5 S" z' p6 o) k
count=1
sum=0
0 u6 L6 T4 \$ V2 Iwhile count<=100 :
" `2 p. x0 z. v* U8 B) T. Y    sum+=count
    count+=1
print(sum)29、元素分类
0 d, F4 u8 S( X  |4 m) v3 U1 f* H  s有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
  h- S' O1 v# l/ d& X" {# Z即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ C' M+ b/ R* `/ O. d, {li=[11,22,33,44,55,66,77,88,99,90]
7 u5 f+ F1 r3 K+ xdic1={
7 T( R% i6 y" N$ _$ H* h/ a. \    'max':[],
" D* G, Z) \: d; e    'min':[]
}
for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
5 D$ E' q4 V5 B: Z4 f+ Q. y        dic1['max'].append(i)
( A+ G7 n( ~1 t) D& ]$ z& O8 aprint(dic1)

) h* S% L: Y5 t6 I7 X---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}