Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

# w/ U8 g! M4 P- I5 U0 [) Q* 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个字节代表一个字符，

2 D# U/ h/ S$ f; x5 E. V: J4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

% ^" M' G6 E6 g( o- n5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

: N" `  w3 s" V8 G/ a6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
: K  k. l  I+ I9 G. tz=1
$ o" D, d! b3 ^  s6 A; \print(id(z))
/ a' d) |& b; S1 g; [, v0 V3 `9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

. ~6 L. t9 A' E8 M3 y, q10、写代码
  F5 Q  Z3 c* O" H3 L. f9 D% Xa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
) f: b3 w/ V; yname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
* [; a! x$ r; d% e" S+ U    print('ok')
else:
# t! E/ H( P& ?) D* u3 Q    print('error')

: d  p/ W8 ~- m* {4 r8 Cb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
6 t! i8 u% W: J* z% u1 t+ ccount=1
! c  q% W2 {% @, g7 I9 K& Dwhile count<=3 :
    name = input('name:').strip()
- g2 {4 v% ^+ w! b8 j5 ~    pwd = input('pwd：').strip()

: h0 L: r+ Z7 W1 K    if name=='seven' and pwd=='123' :
        print('ok')
    else:
, A1 N5 L. U3 J        print('error')
3 {  m4 ]* L2 ?0 d3 [2 B        count += 1
for循环：
5 H9 b8 c; Z) T: M, {. S+ u! Efor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
+ L* P; `5 h: r    else:
# @8 k- f8 F5 o6 G" K, c$ C        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
& l+ B9 X; H. z8 W/ J* U, F0 Kcount =1
6 d  p$ i4 I# Q$ x9 I' m4 jwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
; D8 {' L) Y- W    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; ~+ A: i0 M9 Q& ?        print('ok')
    else :
) i$ t2 ^, C2 M# ]        print('error')
        count+=1
for循环
, b& c8 o& c& _" g8 ^/ d: Yfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
3 y" r( Q6 E# N4 w/ @6 f& _    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 [# F+ e% z  Y* ?% [! N        print('ok')
    else :
        print('error')
3 U! c* q1 n' }3 y        count+=111、写代码
$ j9 \. b: Q& {* k( z& la. 使用while循环实现输出2-3+4-5+6...+100 的和
" O3 H) s/ }3 }2 _  C' t2 vcount=2
& s; b) B8 v0 k  U3 znum=0
while count<=100 :
$ h4 J2 L5 c, s2 U    if count % 2 ==0 :
. y4 s0 r0 \" p        num=count+num
        count+=1
    else:
        num=num-count
! M+ r  G) s$ I  h' q7 `        count+=1
, y2 x5 O8 w5 P" G3 s- i3 _print(num)
) N! I# t8 A1 N1 Q/ e
' ?; z4 [  B9 G# k! Eb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
) {: j! d! N& y( L" V, M0 O. R num=0
8 G# ]! z9 D$ `  |1 `count=1
5 Z7 C9 L, h* e4 P6 T% w+ Y2 d% Xfor count in range(100) :
( Y& M1 I" Z0 [  k    if count % 2 == 0 :
        num=num - count
    else :
5 r5 q; K! ?2 R        num=num+count
/ ]. ^6 S$ D( q8 yprint(num)

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

count=1
while count < 13 :
# s8 s/ E+ s5 O    if count !=6 :
8 ~  C0 u, u/ V        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
8 v7 f( W, [& h( f; K7 n8 @6 nfor i in range(101) :
    if i %2 != 0 :
        print(i)
& }- m" Y2 M' e6 i. B; c6 f
count=0
# x! W6 e/ E* V& e) xwhile count<100 :
    if count %2 != 0 :
' \9 ?6 z$ [8 e2 r7 I" [        print(count)
    count += 1

% r' a' n  t. B% {e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 y4 t' H1 e4 z/ D7 z2 J    if i %2 == 0:
        print(i)

9 \/ r7 p  R( f$ X9 G, n; f! w2 u& Ucount=0
) n% X( ^" ~) m; s) i3 Iwhile count<100 :
/ V) @- m% `$ f; \3 W; p( J+ Q    if count%2 == 0 :
0 s. W8 [: {  k0 L        print(count)
$ E+ M' h6 c0 p    count+=1
! J: G$ ^/ x8 e& ?
12、分别书写数字 5，10，32，7 的二进制表示
5 J- `' @3 g# q
6 J9 i# @# w/ B6 k) g7 S- y7 ]1 Wprint(bin(5))二进制   0b101
5 z) F; h7 v! vprint(hex(10))十六进制  0x5
. ]8 K  k: X) g: W4 Sprint(oct(5))  八进制  0o5
: I* ^; L# G) o14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

& U, V. u  t) D( Z
' U& [5 `4 a  b9 N' y; Q18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
1 m6 ], z& q  c( Ea. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
% q" \  h9 r. {0 A* ?- x* z
/ p9 Y- f: q0 c% ?0 ab. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
% n  q; ^- D5 Pprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
3 y: g% K% w$ d6 N' u5 Ve. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

g. 将 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'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
' W& r% z7 S* |' {" G8 S% u依赖索引
4 E. x; x: O9 U9 \name = "Alex  "
' _/ _. L$ Q' [/ O  c' a  _for i in range(len(name)) :
* I- m5 W- x6 o3 B  K    print(name)
for i in name:
1 J) N8 ^  k9 ^: |: Q    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( G# y; H+ K7 q# e6 y. ]* X  C1 a- Xprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
! [: c9 L6 p  B" k% ^8 j6 `c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
7 \# D* G8 v! H2 Y/ x; gprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
/ Z) _& ?, u+ ?9 g" b, B0 eprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
+ Y2 T* H% {) e5 U0 Jprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ \: Z2 p: }3 k) Bprint(li.pop(1))
( ]. B2 x; T; c& e, G7 bprint(li)

eric
% d9 L1 C" u3 O2 s6 h  U['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
6 s2 d4 q- Q8 Z/ ]del li[1:]
- z/ |* W( c& g. ?print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, I6 M3 i1 P4 N" O( L. M$ j, nli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ d3 S( O2 H3 f3 n9 Ya. 请输出 “Kelly”
; d$ l' w+ L, o+ v4 Pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 b5 ~7 r) P/ c7 s, t  D5 Pprint(li[2][1][1])
1 ]$ R: p) D  F& Hb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
6 v) c/ e6 e) Kprint(li)
2 Y  S9 K% h4 |* O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
' D& x) M, L2 a3 Q, ]' J2 Z# Hprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
/ `+ |; e* [+ `, X( B& |0 xe. 请使用 for、len、range 输出元组的索引
' D0 S5 Z& c" q4 w/ l  tfor i in range(len(tu)) :
4 f: I- ^0 ^/ c0 G/ N. z    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 V, l3 ^" ]3 \9 {9 S. T  _2 [9 @for k,v in enumerate(tu,10) :
+ P# s$ r8 g6 I2 ?+ w( @" L0 H: V5 v    print(k,v)
5 S4 C& Y: L2 C' P10 alex
11 eric
  i# Z3 |- @7 Q# Z! ?. a12 rain

for k in enumerate(tu,10) :
    print(k)
" z" V' m8 R% u& r+ [(10, 'alex')
(11, 'eric')
(12, 'rain')


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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
, ^/ J. O+ I" C2 btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

4 i! ~$ R# v1 u: n! G& i7 r6 D8 \# }print(tu)
26、字典
/ E8 x+ K- ?2 b/ t& t6 udic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 U/ r& R  Z5 T( T) V" y, r    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
/ u# a; L9 M' O7 Hprint(i,dic)
4 T$ B- Y2 s/ ad. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
1 k1 Z9 k$ @( u2 xprint(dic)
# Q# E) B2 R: h' Q" ~e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! O+ U; Q2 O( m, K/ z# Pdic['k3'].append(44)
4 }) K0 g- l2 o& a8 Iprint(dic)
3 F% c! g- r8 E# |' }8 I: }
- @- _: ?' q& k& `: v* U$ Yg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
7 ^1 x) f- D+ U6 s  d, {dic['k3'].insert(0,44)
" n: I5 F) r: L) gprint(dic)
+ o  w2 V6 r$ g27、转换
' ^0 N9 L: P6 a& V" E6 c* t" Oa. 将字符串 s = "alex" 转换成列表  s = "alex"
6 b8 M* W0 y$ z9 c  ~
print(list(s))b. 将字符串 s = "alex" 转换成元祖
# ]  K3 q% U2 n9 j9 j1 |9 us = "alex"
print(tuple(s))

8 D" ~& z+ B* kb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
2 a: {! w- y, \" w! ^* ~* u
  I: ~2 z' p. W4 ]- I
) T) S; K1 I, L" ^2 m+ z* y( V3 Yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. H3 y9 q4 R1 S( z, f' O8 o: M7 @% k
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
% w" S, g5 }. J: k    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
$ s9 z* R4 I) V3 F" \* Ka=n.encode('utf-8')   
( x# t% H1 ]/ L# l% N8 }  oprint(a)
: @3 q, W. |. \$ Yb=a.decode('utf-8')
; K/ O3 g' B: {' }* _. e1 Yprint(b)
, l  u0 z9 O- y1 D( f0 |$ G0 n; u! M% lb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
* f7 A) a- Z) Q" H5 F; Z- mb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
+ E. ^3 V6 L2 T! C! U  F- `sum=0
for i in range(100) :
' u: |; l3 W# N2 \7 z    sum=sum+count
    count+=1
, s% v: K/ Y. r  Sprint(sum)
" m; S5 R* s% f7 K6 `3 p
+ J4 `; c! G+ Q0 `4 {count=1
  K9 ~7 ^' ^: h0 _% Ysum=0
5 J: r' R) v! a+ M0 {* p5 [while count<=100 :
/ j+ D4 a* }* H( g9 \0 u# X" u    sum+=count
    count+=1
6 _, {& Y  k# U* Y9 p( M4 g7 dprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
) M7 w0 @; w' N  y& \将小于 66 的值保存至第二个 key 的值中。
/ N5 U4 R0 {+ S3 B即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
- `$ H* i, n& x& I}
for i in li :
; c! g4 F6 K6 S. @( l    if i <66 :
        dic1['min'].append(i)
: a# K5 [7 u; s" `+ v2 @( ]8 v8 N    else:
        dic1['max'].append(i)
print(dic1)
1 q% U) x. u* N, {
6 k2 b5 m  t7 l+ d% d# y. n---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 y# j3 H, F, }6 m1 t