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

/ g: d+ z4 ?0 U8 I& b2 r9 z! I5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

2 \0 r1 U8 h5 E0 g8 _. {: @6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

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

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

* j3 @; C$ ]% ^# @% U10、写代码
9 ^2 Z1 {+ d! `a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
6 v  D' a# r4 U. J: ^name=input('name:').strip()
9 ~" R5 k/ j; f6 ?+ L6 S2 upwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
, f9 I% y8 k6 O5 e' o% Qelse:
0 A  s" Q7 J; \; `. |    print('error')

& l( R4 T* g2 A7 @8 qb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
  h  n) d) N  G3 Q( Fcount=1
while count<=3 :
) _3 H5 m4 [  X- m" N, L    name = input('name:').strip()
5 I% V. y7 T# u    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
* E5 `# r3 A8 p8 Q: L7 O3 l        print('ok')
0 q, C  Y/ y  E* D' N9 b) F; t" J    else:
7 k0 {, X/ \6 i0 Q5 x* p6 g5 A- D        print('error')
        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
& |5 n( D, n' v- e8 C' h    pwd = input('pwd：').strip()
" [# i! Q. S: Q( l! Y
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
- l# k  z5 G- Z' L$ k% P        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
8 [; q8 D: M; }* b  y  f7 u. m$ }while count<=3 :
: g8 G% l4 J2 j) L5 O    name = input('name: ')
6 L* f* c- y9 ?: D/ l# W4 P0 K    pwd = input('pwd: ')
4 e! e' ]3 q: K5 F2 n    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
! B8 }5 u1 @- a/ v  K    else :
( L' p' R  E1 B8 |$ x        print('error')
        count+=1
8 j5 B% q/ q  L" Gfor循环
. t6 l9 F; h0 Y* E# i6 gfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
+ O7 L7 Q4 B* S3 E5 K; W    else :
: V! o) h5 U% y- B/ ^, c2 ?% @+ I        print('error')
: U/ d$ E- r/ b- l/ m2 x        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
+ ~6 G$ M, W' v6 h; V1 D7 wnum=0
: R4 e( R8 h# S+ N# I9 i* d! [5 ywhile count<=100 :
    if count % 2 ==0 :
- r+ H* P, J( v, n% C& c4 W1 [        num=count+num
        count+=1
3 J; T" [7 |) W& a" c" n+ b0 U$ I4 R# X    else:
2 J; }7 x) c$ r! }$ O0 G% n4 r0 A; k        num=num-count
1 @; V/ d* ?- \; U5 O7 w        count+=1
print(num)
  c$ A3 d3 l; @& r
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
  k5 |' o$ H3 W* F/ o0 A! d6 |5 e num=0
% L  H- b/ w6 |$ g; z1 C5 tcount=1
4 i9 F# x$ K$ T. _  Tfor count in range(100) :
    if count % 2 == 0 :
5 m9 e( c9 s8 i& \. d" w+ T0 E        num=num - count
9 y  N+ e, G. m$ V. f    else :
        num=num+count
; W2 G! C$ P5 y5 U5 hprint(num)

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

count=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
8 [7 N: N2 y, u, d; f
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
( h; i! A* a2 L1 C6 V) Afor i in range(101) :
2 p2 w$ D! P8 p9 e3 \    if i %2 != 0 :
  \6 V1 Q' C3 K1 Z) X( U        print(i)

+ a( R3 ]* Q# S4 n! z# ~/ |$ \# w1 bcount=0
$ \4 N4 t: g6 U7 A! B& t' j! Awhile count<100 :
+ Z* n: s7 y1 r, L- c: W' r. n1 f    if count %2 != 0 :
        print(count)
    count += 1
7 L5 y) q8 b& N6 Q0 e, u$ v4 ~
e. 使用 while 循环实现输出 1-100 内的所有偶数
! c8 A. K7 i' s" Pfor i in range(100) :
    if i %2 == 0:
. x& @# X5 ^1 Y. G( r" @5 Q/ i6 L; }        print(i)
, X$ v. c  ~3 q5 v  a/ F2 Z
- M0 Z, }$ K8 C0 O0 l2 E: Qcount=0
5 M! }( n, i. Q. T3 @1 Hwhile count<100 :
    if count%2 == 0 :
        print(count)
    count+=1
8 {4 @! W( s2 W4 m" }
12、分别书写数字 5，10，32，7 的二进制表示
0 z7 ^/ e9 D2 {! ^" T
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
0 I( T0 S, n& ^* E. O' n& C  t6 Fprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

: h  G" Q$ P7 u  i. b0 o16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
/ v- T/ o$ z* y% [17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
! v% e0 F% k- b8 ~! {print(int.bit_length(n1))  结果  3

' F" w" U: u" d( V
. B, |+ J2 M! U9 z8 x# Q# \. k6 G18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
  O, U$ G! a& X& {. R7 qa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
& j% l/ j5 W7 W) a4 T
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
3 a2 p3 `6 J% V0 Q+ gprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
3 m2 Y3 z% L+ A. Re. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
0 k3 a1 ]- L4 ^! ~$ D
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'))
7 e7 ?) a( I7 \# ]& A21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
2 k1 K8 p* k% i2 P& @依赖索引
5 W' E- p$ l3 C4 t! oname = "Alex  "
for i in range(len(name)) :
/ M0 C& D8 g4 p3 t- |, Z9 H    print(name)
. b2 o# A# V! n) O8 b' Yfor 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']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
4 S# [, I0 k; ~2 M% w) \$ k. {8 {print(li)
['alex', 'eric', 'rain', 'seven']
  z: }9 {/ X! F7 i% j( u' jc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( s+ q3 z0 ^* F' v" Q+ c: ]print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# R( @3 }% b+ M- H6 R2 x) V* Kprint(li)
" l9 m6 h/ N& a- me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
6 p7 B# H2 J0 X8 H' y8 tli.remove('alex')
. D4 V$ `# G* K) h" ^, Cprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
0 M9 e1 f9 ^0 y) n) U  _9 tprint(li)

+ K% d% D. [' w5 u4 [( K1 x+ a, xeric
+ I7 K5 m& W. d3 U['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) e7 q# v+ |! C7 i- Qdel li[1:]
# U/ F& D$ A- i" e: v! b& Q- mprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
  d4 l6 e2 P' l; uli = ['alex', 'eric', 'rain']
, G) I1 h' s  Z' l0 v: ^1 Ffor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% e2 }7 d* n, T2 E  fa. 请输出 “Kelly”
+ Y, V( t5 j9 N/ C( y; j' a! |li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
) B# X8 X: u' W3 U; Yprint(li)
& V/ r7 t2 D( {# m; z24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
# E. U! H0 b$ Z6 c! h+ J  A3 U* Kprint(tu[1])
/ E2 x2 X. Z" i1 k0 re. 请使用 for、len、range 输出元组的索引
, f! a' Y8 Q) @8 Z' m, o3 u* lfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
( U) |7 A1 a# d    print(k,v)
0 X) I" }1 m4 }, \% ?10 alex
6 q6 R; \$ z8 j7 ?11 eric
12 rain
: U5 V' o) B  C0 i" {5 H  p0 ?1 m1 L
% z8 j7 @4 P, c. ~0 Jfor k in enumerate(tu,10) :
% y0 m2 f+ ?6 }/ `6 f    print(k)
(10, 'alex')
(11, 'eric')
: i1 M) j8 l! A2 L4 Q& v2 z/ [- q(12, 'rain')
5 P1 f( a: e/ d1 y3 X2 y

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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
5 Y$ W0 a7 n) F  qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 U1 d( d/ J- |( ures=tu[1][2]['k2'].append('seven')

/ F7 f  e- o) r5 N0 c' Zprint(tu)
5 r5 y0 ]( W, ?+ I$ R26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
* w7 \$ U4 U- h* V" K2 iprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
( q" y: T+ h3 H. kprint(dic)
# k, g2 a9 b7 E% V% H1 g' o0 Re. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
5 p; V7 s% K' u& |$ K1 xdic['k1']='alex'
' ~* M. k+ _8 F& |$ H' l6 Z$ R3 iprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( `, r, f( ~" G, Idic['k3'].append(44)
print(dic)

5 _5 i, x) F, }: cg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- {" n) _6 s8 `- G% j) t2 F, L9 ~dic['k3'].insert(0,44)
3 _) L+ X; Q4 qprint(dic)
: \' ?( \$ r- ^, P+ C+ @# c- O27、转换
3 ^8 y$ D% A, t  S& k% C* d2 da. 将字符串 s = "alex" 转换成列表  s = "alex"

3 l& v1 t) z. B7 c1 v7 ^print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 ^8 ]% P% U  ns = "alex"
9 y9 o2 X& u* H* vprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
1 s7 Y/ x6 R; rprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
" C$ n  \) G1 D# s/ ttu = ('Alex', "seven")
  b" H# X) l. P: ^6 B( ~0 y  wli=list(tu)
  o1 A' h. s+ [3 tprint(li)
' t; X1 q! \: T/ m2 {% a

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
! q/ l5 {- R( z& r, g) v! J5 {
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
7 S+ \: L% o* Qa=n.encode('utf-8')   
+ I! h8 c* S! i, Xprint(a)
" ~1 y& O- \5 ]# P9 F$ r5 ^' V4 Wb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
( r' }. H; Z! P+ s) m% E9 {print(a)
' Q" ?, C8 |( Rb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
2 r6 D; R* g9 tcount=1
( B% I5 z) ^8 c. T; xsum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
; q  |' K8 v) S4 u- f4 b9 V) D& n! O8 e
; A6 o- `& L2 r! d3 z3 L; Z$ t' \8 hcount=1
! ^& d: X9 H" S! q0 J: l& jsum=0
while count<=100 :
' f8 D- N- y- P. J0 x# \    sum+=count
0 c( O) o6 {) `1 h( ?) v    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
: U1 d$ A1 U/ w8 U即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
2 f8 Y' n2 @! S  h* |5 c0 ^    'max':[],
9 e- b, M! p; f# b  U) e- j5 I; ^    'min':[]
3 S) Z8 P, \3 m}
& p5 H& e* ]% H; G  H+ {- yfor i in li :
    if i <66 :
5 D8 ~2 W. j5 T! c2 ?/ \1 P2 k        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
6 u2 }, f$ t5 R7 v" [' [print(dic1)
0 w% C5 u3 p/ [) s) B$ u, C  N0 T
& g4 R& W! x4 d; \) b  }---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}