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

  Y& I9 T4 z* g2 U( N4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

- F0 b3 q( l$ C$ @5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

. r$ K( r( S0 l2 y8 _- u6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

" W2 M  o! ?  l10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
$ p: B: P- K' P* l. ?/ g% Rpwd=input('pwd：').strip()
: `. `% v3 x, Q* g) hif name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
: S4 o4 p4 |& p6 h/ Z: s* l6 u
# X) f( q' a/ T) Pb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
  C; N5 R6 b6 r8 ^    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
$ p9 v! ~1 [" }. q  R. D    else:
        print('error')
        count += 1
* t' j5 l" @2 X$ h$ s1 Jfor循环：
5 U7 G0 ^' A& I0 {% S5 g; Tfor count in range(3) :
    name = input('name:').strip()
3 [6 T0 {; D/ E8 `" N1 ?1 S    pwd = input('pwd：').strip()
5 ]9 r% Y9 {1 f2 S1 F7 v- {/ W
    if name=='seven' and pwd=='123' :
4 E& K- d* m+ S/ k3 g1 C        print('ok')
/ e% D, I+ s- K" h( }* M    else:
/ T8 ?$ p1 o; L, B3 }6 y        print('error')
* n& S; H" ?. ?* ^        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
- \9 a( F1 F! ~' Z! C- v& cwhile count<=3 :
& x4 f3 u, e0 M5 U    name = input('name: ')
2 d  b- ~" j* B& u    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
! Z$ H' j( c* l    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
  j" S3 U& r& q1 D    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
) O" j) c, r3 M7 r2 V3 [        count+=111、写代码
4 H! U. ?6 R/ [7 r8 Ua. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
4 ]/ O2 k* P0 y: d' G# O. Mnum=0
6 I% h# o' t  L$ D( h* X! y; V6 Uwhile count<=100 :
) `& M2 i5 Q; X    if count % 2 ==0 :
' J# G) R: I9 y" E9 W        num=count+num
4 q4 c2 y7 |, P/ f5 Z. L5 A7 z- T        count+=1
' ^& a6 E. K; _    else:
: H; m  l  d7 `. a3 A) n" d        num=num-count
6 o6 _& r/ c4 u# w5 o* k6 I0 [        count+=1
2 p& q6 W  L$ `) E3 }; _! v+ @/ Dprint(num)
) K! c1 c8 K% V
4 \2 x2 @+ }+ a) r9 N' Bb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
5 c; P- @/ b; B0 w+ Q num=0
count=1
: ~4 O4 U- i( Nfor count in range(100) :
- M) Z' ~' A4 {    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
+ T9 {( X; V3 b+ \1 ?. P1 E# }+ m& [print(num)

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

, }7 \# M' R3 J' Ocount=1
while count < 13 :
    if count !=6 :
" M! `$ _/ @6 D6 u, g$ q6 a( `( v% b        if count !=10 :
( s1 E; h# s2 r            print(count)
3 i5 l! b/ B' m  ^4 Y7 p
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
0 P9 n3 S0 o* }for i in range(101) :
    if i %2 != 0 :
        print(i)
( q; G, b3 [! \" r& e) f
count=0
6 T8 S0 T# O' u' xwhile count<100 :
" j, z/ i) Q, A) t9 l4 p- j: b# L    if count %2 != 0 :
        print(count)
' g0 B4 ?) P# R! M# _4 }    count += 1
( U0 S$ L% q/ L, Q& T- P6 J) B
" p1 ?, U- g! k( m  L4 W$ Ce. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
; j, ^6 h$ p! n- z( n        print(i)

3 s3 {2 d3 R8 }# i, p7 r5 xcount=0
while count<100 :
+ a9 `' A. K# X. t: M    if count%2 == 0 :
        print(count)
    count+=1
, C7 J# @) @! Q+ }! \
0 g: [9 ^* \5 {2 v, j12、分别书写数字 5，10，32，7 的二进制表示
7 r& L4 l7 c7 \2 C. G1 F
, _5 S8 i  z( D/ V6 }; B' f; D; cprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
. b7 S, i& d1 D( m9 g3 N14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

7 E. ?8 Y8 ]1 }8 ]( p6 B16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

& H- `; ]. r7 V. ~- B6 k1 V# Z18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
; R1 y* l+ \  ]1 y  C9 \7 H1 Ta. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

  V2 T: X4 |+ gb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
( [9 f4 b: G3 m9 }+ xc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
8 O# C6 u. m4 y% N' @. ^6 j3 }; l8 ^, jd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
7 X/ k2 _3 j& R' x8 @9 Mprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
5 c8 Z- s+ q* {, G- C- ]
" q8 H8 O: ~' t8 o) h9 u9 R/ B4 rj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
, {4 ~0 p7 N, F  M& y. c21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
# h" z  l/ C- s8 M$ q5 b; W8 r& }依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
+ X! x( d) }* Zfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
( \- r9 l+ S6 j8 ?  R& Q5 j# j22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
5 F  s5 Z; l& ]3 F- Lprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 d+ c- ?$ J1 c$ J% O3 _8 H. P- g' jprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
- r2 `+ v: [! m$ B' K指名道姓的删除li = ['alex', 'eric', 'rain']
, h, S( n' n, D' K& d% }li.remove('alex')
$ j8 O  m  V8 R0 }1 uprint(li)
) T: _, G% i/ U/ ?5 e! af. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
; O, H+ Q* y1 a  D; X) K- vprint(li.pop(1))
1 w* O6 H4 S* s4 q# vprint(li)

) u6 i5 R" l" D3 y: T, \+ ceric
) ~$ K1 \) D/ m' O6 h  D4 H! ^['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
' U$ G4 Q2 \& k) O5 @print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 R( Y5 b! @* C# Eli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
, s) I% c  t8 f3 I7 e1 K: ~    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
- Z3 i  n' t% d0 d) ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
# H+ t. c# d# B$ W% K3 mprint(li)
2 Z0 v# T$ z1 R) u: T4 x24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
' ]0 b1 D4 p  x9 f  s* Iprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
3 s9 C$ e( n1 V( ~) A    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 p1 C4 Z$ y' F' Ofor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
  m% \: s0 H% f1 Q12 rain
' n3 v; b2 e8 h- Q- A( Z2 y
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
  w2 ^# I- i. w3 A9 B/ S. b1 A(11, 'eric')
(12, 'rain')
1 G9 i* L/ r9 A- g
7 y1 C! y! C) m1 o4 Q  C( P
25、有如下变量，请实现要求的功能
# [7 Z8 M) E+ T2 |, V) R* p: Htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

2 ^' j! `5 N! Q5 n! Rd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
4 J2 S' c1 @- C/ v4 q7 Etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

) l4 ?1 x1 j5 y6 bprint(tu)
6 A1 E/ ]  b$ b/ ^3 N: N3 |26、字典
: g+ p; m. R1 bdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% J" e1 R, B9 E3 z) K    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
- {! V8 y1 C  ?. N8 [$ fprint(i,dic)
) H5 z9 V& S5 j8 c# h% xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
; g1 w9 H6 B* i. J- c* kprint(dic)
9 C1 ~/ R) ^6 V* ze. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
5 g& Z% b: N& cdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
. k6 @- U" g! y  m# `9 k: Wprint(dic)
" P) J& {( d% o4 P2 L# x" h
$ l3 D3 \  a2 a+ f( zg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
" Z/ `' D6 X; zdic['k3'].insert(0,44)
print(dic)
( r( S% ~) l3 \# u9 g9 B* f27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

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

b. 将列表 li = ["alex", "seven"] 转换成元组
! |" [% m: U# Y8 S/ Q( G  ?2 ?li = ["alex", "seven"]
/ d6 t. x) ^# ?! iprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
, v- f% d  B" G* Ktu = ('Alex', "seven")
li=list(tu)
print(li)
/ F0 U% Y" L9 o
+ n1 C; L7 w: K8 w
  ]; S, ^$ H8 u2 D# b, vd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
7 U8 P1 w# H0 M& j! n
  ~/ x' {0 W7 l/ f1 Odic={}
- u3 N* N" V) P7 [" B% ^  t6 Ofor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
; L/ V) R  i0 N% U8 Ka. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
6 P+ k3 }& \. R: f0 vb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
6 Y' k: t# h  Y: [  C+ f1 cprint(a)
b=a.decode('gbk')
  g. r! r+ R; E& p, |) f4 tprint(b)28、求 1-100 内的所有数的和
# O$ R6 W$ T% p9 Scount=1
3 G  i! _9 x) l- _# L4 [/ `sum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
0 @4 @3 Y9 C$ ^9 p2 R+ K% O/ h* W: G
count=1
4 [# H% C- c0 B; |1 nsum=0
while count<=100 :
    sum+=count
5 `* m" H. @, b( n1 T    count+=1
print(sum)29、元素分类
2 Z1 K. t/ R6 D+ A* ~* O: ]有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- i/ \+ o& F" [li=[11,22,33,44,55,66,77,88,99,90]
" Y3 X' F- z& v1 L* Qdic1={
9 d' x' B1 h: K% W    'max':[],
    'min':[]
; e* f7 g4 v! {  z" T}
for i in li :
0 t& {! a# w& a6 z5 P* z  g9 \  P    if i <66 :
        dic1['min'].append(i)
& }( d# P1 T' `/ I' P. a    else:
- I/ F5 `+ Y3 ]# C' w+ M        dic1['max'].append(i)
6 o& t$ O$ ~3 A8 }: Q+ `* ?. Yprint(dic1)
' [' K: X0 b5 ^7 O2 M* u* @) q
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
# [- H, L' K5 d2 N