Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

! {* `: N5 {* f- T/ 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个字节代表一个字符，

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

7 k7 N6 n! G6 }$ i9 ?5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
  a: ?+ ^( B- Az=1
2 i- n- C: b: y, W! `+ Wprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

9 a: l3 n" r% F2 T10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
7 Y- r1 Z0 m6 _1 r) ?name=input('name:').strip()
pwd=input('pwd：').strip()
" o; O$ Z3 c, ~# l. lif name=='seven' and pwd=='123' :
    print('ok')
else:
3 |3 z" ]: @; Y3 u, Q$ A    print('error')
/ U' A* u& g$ r; r& F, N
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
# l% j# z# N: n7 @6 F0 i. Icount=1
+ {* i8 ?+ a: D$ y8 m% q( Swhile count<=3 :
    name = input('name:').strip()
& O# n4 c; L- c1 ]    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
4 J4 F, T+ \- A3 t/ X# p        count += 1
# s. ?4 N5 E5 M2 vfor循环：
; \- Y5 G0 o; K- m. ^) jfor count in range(3) :
/ d+ q8 c, W, @) E+ M* l    name = input('name:').strip()
3 t4 L; i! x3 A6 f' L    pwd = input('pwd：').strip()
4 M2 t- k5 a8 h- ^. V: i6 _
    if name=='seven' and pwd=='123' :
4 p8 l. b$ Z. H0 t0 n( f        print('ok')
4 y, O% B* P/ t( N9 x$ U4 Y' h+ o. U    else:
* L, T, v+ f- `* l5 A        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
$ s$ m3 q! `7 {, x6 p4 X1 ccount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
$ u6 _6 b; S8 h2 Y5 H5 W2 ]  @2 q5 M    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
- V, w3 q) v6 @) r) {" q8 b8 F/ T    else :
% O3 O8 D& D7 h. c; `5 _' z3 T        print('error')
4 }6 S( N  d! P3 k        count+=1
for循环
1 e+ t7 U2 L0 ~for count in range(3)  :
    name = input('name: ')
: h, ~/ T0 ?" ^3 D* q    pwd = input('pwd: ')
% W( _8 U2 Q+ R3 n+ q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
# N& Q8 u% G2 X2 Z+ m" u9 G7 M        print('error')
5 e1 J+ ^4 x3 f* j8 T. s% ]1 L        count+=111、写代码
4 a9 C& b( I9 ~, oa. 使用while循环实现输出2-3+4-5+6...+100 的和
* y- n0 ?& f0 W" n& H' ^& m% {count=2
" o/ r" E) H; g  V  _6 i& jnum=0
+ p8 e2 ~* R7 x' I. h2 h' qwhile count<=100 :
    if count % 2 ==0 :
+ r0 e4 X; L- ?) b        num=count+num
        count+=1
( Y* U2 r$ c. O- S3 Y+ E    else:
        num=num-count
( ~& P( Q3 e! ]* f. ~5 F! M; N        count+=1
print(num)
9 w* M& n4 Y! C$ O0 d0 K. @
% P$ \. \, u1 r  v, Nb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
9 o- D/ b  s% V1 G7 n% hcount=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
2 q% k4 u  X; c  `" i) X    else :
2 k. M+ U! d! U        num=num+count
- I- o# A" I, ~, tprint(num)

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

count=1
4 v* ]$ E4 @% E" x- ^* F6 Rwhile count < 13 :
    if count !=6 :
5 M' ^: N5 ]% k* s6 z. `8 A: @        if count !=10 :
  D& f* I7 U; K2 H4 A            print(count)

& K# F6 A5 R, G, a8 Y8 R/ L3 T) J7 F    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
9 o/ d/ G( n) B7 g2 \' g$ zfor i in range(101) :
    if i %2 != 0 :
        print(i)

% x$ i6 q* _) `1 scount=0
while count<100 :
  Y5 M3 [1 R, N, V    if count %2 != 0 :
        print(count)
    count += 1
! t  j+ P, N; o
e. 使用 while 循环实现输出 1-100 内的所有偶数
$ ]+ v  b  n' i3 G- u: i2 B. [6 W. Bfor i in range(100) :
    if i %2 == 0:
3 q' B9 f# T6 ]+ L3 {5 s8 ~        print(i)

count=0
while count<100 :
0 j, V" e0 {/ _$ D+ G    if count%2 == 0 :
        print(count)
    count+=1
; s9 x- \2 i' ^3 J
12、分别书写数字 5，10，32，7 的二进制表示

0 c& M* E3 u8 t/ T- }: \8 f, \print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
3 U! O7 ~1 I$ r8 @" ?0 W" @0 v8 Q14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

4 P2 u% s) _7 g8 d4 M16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
6 W! E2 ?2 m+ ]( T, P' e4 f* e& kprint(int.bit_length(n1))  结果  3

; K7 [6 M9 V/ V& O' D" k& Z8 m
- Y8 s3 q+ i& b; Q& k18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
' h1 B; i+ u2 x- e. Uc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
/ g' y4 u( R( T" i9 {5 b2 Z& Bd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
0 F1 w0 W0 X" V0 v$ p% Rprint(name.replace('l','p'))   apex  
8 Y# \7 W  B* X0 Re. 将 name 变量对应的值根据 “l” 分割，并输出结果。
( E. }' x' l+ S* J- V4 @print(name.split('e'))   ['al', 'x  ']  列表
- s' j) W# A: |# @, l. q
. h" a! v) z! c, W* j" p; Wg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
1 f* P+ D( g) Q# h5 c( E) m
0 S& }0 d0 w( Q; O) B8 i4 fj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
, o3 a- E( H' ?$ n) I& T5 p21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
; O" k2 ^0 h4 ~: U6 K6 G$ d! L4 i3 Efor 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
! }6 d3 P' g0 R, V22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
) i" f2 S7 d! l1 g ['alex', 'eric', 'rain', 'seven']
! p. j, B, O+ C# ]5 X8 h, l2 xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 P* V' c3 V% s4 ]; b8 cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
; K( C" b2 k/ S0 v+ c+ P4 Q1 Oe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
; q, O, T* Z3 jprint(li)    ['alex', 'rain']
4 W6 b; d, r! h; q" J* t3 J指名道姓的删除li = ['alex', 'eric', 'rain']
, e- {$ N$ `( X% ~, Cli.remove('alex')
print(li)
' S! m$ Z$ M) w/ `/ Uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ B8 R/ h! h4 v6 H( eprint(li.pop(1))
print(li)
! {5 J0 U9 g8 a: l* X/ F* T& u
$ `8 O9 l$ [, Z* V% b0 Jeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
$ b/ o( R0 @/ e$ }0 j% a2 S! z# D# d* A. V    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])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  N  |! s+ p; h- G& `; qli[2][2]='ALL'
$ l3 G; V4 b2 W0 M: V' ^6 P5 mprint(li)
- D2 E. O* C1 h+ x7 B/ ]+ R' P, {3 `24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
& B# R) P- p1 P* `; I) u    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
8 I" s; Q' m2 Z3 y1 z3 n    print(k,v)
" W( H2 A% x- S$ w6 J. K* v10 alex
/ e' H: G6 K# z* q0 z& @11 eric
12 rain

: [! G! c$ }" J6 [% [7 |for k in enumerate(tu,10) :
    print(k)
2 \8 v) G! x) Q6 \(10, 'alex')
(11, 'eric')
/ l- v5 G( k$ q5 U2 C$ m(12, 'rain')
# j6 R7 @" Z3 o- T" s6 F

1 ]1 W& |; H( s8 r  L25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

4 e* @2 N; S6 t( f8 `* j1 O5 Z- R* @d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# a* b! A8 R) I9 s+ l# G+ a: @( X8 Ires=tu[1][2]['k2'].append('seven')
. X- t# O# K. _, t$ L* P- j
print(tu)
: W. m; l' J5 I0 O; ?26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
- F7 S) j4 l" g( c" D+ Tfor i in dic:
- q( @8 b1 s: |    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
/ u( g' M  ]  B& b; ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
' y6 X' B& r1 ~, a% r  b* [3 lprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
% o# N6 S+ D2 t+ A  zdic['k1']='alex'
+ G  t$ U! |( M: I+ Xprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& n, i# e8 O0 U; W7 d4 W- r9 Zdic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
) n! D; b( a# D. S5 ydic['k3'].insert(0,44)
. {# b1 k( b4 T7 qprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
7 q/ M9 k2 _7 P, C9 N
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
% Q' ^, C; n: r% h' Y! X  l6 `print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
" f7 X. L. U8 B" `tu = ('Alex', "seven")
li=list(tu)
1 b2 x: t* T; {- I; hprint(li)
0 k1 t0 N  R# x' c; J1 T0 Q
* q: M5 k+ ~8 \7 i
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
' n8 g) E6 W$ F/ U8 Y
# i% k+ X, K/ k( Fdic={}
' {' D. i0 x6 ^3 Z! o# D9 Pfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
9 A% s/ O: @) }a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) q8 M$ i+ ^; a* |a=n.encode('utf-8')   
print(a)
& ~8 a% a1 N$ Y' Yb=a.decode('utf-8')
7 e" l! s* }/ Y: V; O% Iprint(b)
" w6 V1 K: t- b* Hb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
8 u2 |: W' Y7 C& a' Y7 Mb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
; e% b: H9 e4 r& u9 g2 p  F2 I+ Zfor i in range(100) :
4 @- G# P# r+ U    sum=sum+count
    count+=1
print(sum)

count=1
sum=0
+ t; A; [& G; z0 Pwhile count<=100 :
& P) d7 ~3 d; _9 M2 {    sum+=count
+ q( y( z# U5 h1 _/ Y    count+=1
, \5 n4 j; S* l( u6 R  Oprint(sum)29、元素分类
' A* X" L# T2 ~) ~5 Q+ {8 d有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
) x, b9 [0 k# ^即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  H' E) E. B# u0 m  Y% H8 Lli=[11,22,33,44,55,66,77,88,99,90]
. a& i2 F4 r; {  K: P5 }dic1={
    'max':[],
    'min':[]
% X% Z1 I5 M$ V, P* U( I}
& e/ \$ K5 ^/ n0 I3 M  W7 R6 x; O! f& `for i in li :
    if i <66 :
9 ~2 x4 w- c& J8 Y% _: |& G6 T        dic1['min'].append(i)
    else:
. _% N: E: J9 d! R        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}