Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

* X& g1 k1 n4 t" \5 U: @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

% p6 w8 a( S/ J  z" v0 i5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

. U7 H; O0 B5 \' h* r8、如何查看变量在内存中的地址?
z=1
print(id(z))
5 Q2 \: r4 y2 X9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

& d# m6 |- S$ `10、写代码
! _  a: e* ^" U1 u/ C, B, G  Ya.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
& i: X6 K6 A4 L4 n+ F5 [* l- n8 }7 rif name=='seven' and pwd=='123' :
+ R2 z' v' Z' V+ d% t    print('ok')
4 T8 Z7 t& u: X0 \else:
    print('error')
8 h# k$ _& g; k) q; s$ T
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
* `/ o( Y% g, g; m/ Z- d8 swhile count<=3 :
- c8 F4 k* }+ W( c1 f/ Z    name = input('name:').strip()
    pwd = input('pwd：').strip()
3 I6 V' o/ J3 N/ T4 s0 ]
  X$ s) C$ v/ U' ]: K- _& L    if name=='seven' and pwd=='123' :
+ @% Q$ h: o1 S* H1 ^. V        print('ok')
8 d% ~" g8 B/ _+ o- U  z    else:
        print('error')
        count += 1
1 i# T+ q/ o$ P: M" Ufor循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
: R4 k/ P: ]7 v/ i; N. c7 Y! {2 {5 Y7 I
    if name=='seven' and pwd=='123' :
; ?- J0 E2 G, F! W* u' j( D# B, \        print('ok')
8 R& x& P) _6 W    else:
        print('error')
% H# m- p. `, o+ X7 |        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
& e, {" ?* B6 C) D% }    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  t# g* H: l# i        print('ok')
    else :
$ {0 J8 k9 b; [# [1 ?- b        print('error')
; E% L) l1 o6 T/ G; @        count+=1
for循环
" l0 C* Q; H6 V% w9 m+ Y8 Xfor count in range(3)  :
    name = input('name: ')
8 u9 [& `2 }+ `' ?    pwd = input('pwd: ')
1 H1 r9 l% R: V( `6 T& k7 _    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 G: H% b% c* [        print('ok')
    else :
        print('error')
) c) e" O0 I; ~- R% }        count+=111、写代码
) |9 h$ p  s& L+ h# m8 t1 R  ha. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
    if count % 2 ==0 :
0 b, G9 V  |- h5 R. M% O        num=count+num
        count+=1
* v2 v3 T0 h% z: t8 X& u    else:
$ B. B- W( ?8 i: q: J6 L6 [        num=num-count
        count+=1
, \* ~5 V/ F) A6 C! Mprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
" d) p, F* p5 x( s num=0
" j4 q8 |8 n! }) C$ n* tcount=1
/ N. A3 `! L; i. h* x  z5 Cfor count in range(100) :
/ y' v1 m. [. A9 J5 M    if count % 2 == 0 :
        num=num - count
    else :
' U, H# }2 U) J. e/ h2 ~3 x        num=num+count
8 P# ]  a+ r& o- W# {6 fprint(num)

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

  A8 U* }! m( r: R7 Ycount=1
% l0 s9 C5 c0 \- \while count < 13 :
    if count !=6 :
$ V0 I/ }( ]* U7 f( X        if count !=10 :
, D$ s- R7 d2 E3 k) a            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
1 P4 Q( |+ O: ^1 g; M
count=0
3 ^( [3 E5 W9 n+ @) F% lwhile count<100 :
- [. x7 u# x% e  C0 f    if count %2 != 0 :
& Z  n0 E: B3 k: F2 W% V+ o        print(count)
    count += 1
+ O1 U2 I5 b# Z  w3 i! I+ ~1 U
- u/ g( X# F! T* W( Z0 ~e. 使用 while 循环实现输出 1-100 内的所有偶数
- G6 y& i' E+ J$ g$ P& a" [for i in range(100) :
# F/ Q& s) D, @- m0 R# ~+ K; E  [    if i %2 == 0:
        print(i)

count=0
, p+ A8 y" e0 q; R8 ?- C9 Xwhile count<100 :
7 F2 F5 G" s" }- b% y7 @    if count%2 == 0 :
        print(count)
! E! w8 {4 a0 }) S    count+=1
& C6 m. I5 M; i! H2 h
12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
& F- l) c. P) rprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

% O; v+ S3 ?9 d1 K# Z$ w9 ~4 U16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
* o& ^+ ~: T( s1 f) I& i+ Aprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
) h7 g2 l% Q! C2 }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
* @" m/ u/ L6 rd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
7 N  L( k4 B. r2 u/ [8 Tprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
8 e8 r* h8 V# @1 ~4 z8 G5 u0 j" mprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

; r0 S+ o4 E  _  ]& ^5 Y9 yj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
/ C( [; O- D( [1 w21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
/ W# g6 M* u4 }8 }3 v7 Dfor 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']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
# p/ X0 x! |7 G6 P2 p; A/ k! @/ Wprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
* h' J5 Z6 W% ], p" m0 uprint(li)
4 ?! {5 k/ G/ R2 N9 a2 ^5 {9 De. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
1 @$ `" T7 q6 tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ X! |0 R' S0 y; [7 t/ Uprint(li.pop(1))
print(li)

- O- p% @# l, L& t- H  reric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
' Y4 b; `1 U& F' _) |( f3 X2 B, H" ]del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) G. Q5 Z- Y7 G7 z  c1 c2 sa. 请输出 “Kelly”
8 O( n" J3 D1 W" c, p8 ]li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
1 J9 |! y+ ^' O* R- L8 m5 Bprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
7 g8 @. W5 O1 W+ y* }* o9 `a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
5 h+ V3 H# B- ~' }% ?' u) Jprint(len(tu))
0 h! r! }6 ?7 C0 `b. 获取元组的第 2 个元素，并输出
" w7 V: Z# x9 a4 ]' f" D- U+ \print(tu[1])
( e! B& ]' ]. x* se. 请使用 for、len、range 输出元组的索引
  O* S1 @6 }/ r% zfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
- w/ w. P8 X+ M: _. ~8 Y    print(k,v)
3 C' L# p* e% K- P( g; Z, s8 T6 @1 \10 alex
/ |, M9 {) N6 m3 J9 t! u0 e6 ^11 eric
12 rain
* N8 k% s" \- B7 M8 L' V
& v3 w& ]; v0 m$ ]for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
+ L2 J# D+ f9 d9 w" Q(12, 'rain')


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

元组，不可以

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

& D/ G2 i% l/ _. C0 iprint(tu)
26、字典
7 o9 y8 u! c$ P0 m( ^8 |# kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
& p" X! q! W$ A/ H    print(i)b. 请循环输出所有的 value
' h$ w) D6 R: R* e5 l3 e. j$ A! \for i in dic:
  b$ q7 T8 @. V% Z    print(dic)
7 [; ~' ~" I; c/ Ac. 请循环输出所有的 key 和 valuefor i in dic:
3 N; D8 Q/ V+ m; vprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: g% n1 [+ m- {: t9 a/ s* |dic['k4']='v4'
- d5 a  y0 S8 r0 z5 {  y( tprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
% W# ]( |  W" W; n: Q1 Adic['k3'].append(44)
- o" ]: n8 e0 q+ Zprint(dic)

# ?* Q  ^1 k6 P) t7 ~8 zg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( J3 e8 b9 V: r% m: F3 mdic['k3'].insert(0,44)
) B! y, y" I& j- {( b+ {print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
& Z: M6 v/ a9 L
5 y0 M4 a4 n6 E( U+ kprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
7 c) Q" ]/ l7 A- T0 \. [; T
6 H* A; B) P. W; m6 f5 xb. 将列表 li = ["alex", "seven"] 转换成元组
* t( N: Z8 h: w4 ]" dli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
- }* e% W' F9 i% c" Cli=list(tu)
print(li)

2 |1 C' ?% }, ]4 K/ H. [* \
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

+ X7 Y( p/ h/ l) e/ T1 K! p& hdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: I' K$ K' U" R+ p$ {! E4 l  X; ha=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
- n2 A$ Z' H8 P' X4 j; kprint(b)
$ e) W# Q- d+ O! w4 h, F) A: mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
; V5 ]0 {% k# m9 Q1 kprint(a)
( T3 ^, B/ U/ k3 ?b=a.decode('gbk')
% M4 V: @, D3 Cprint(b)28、求 1-100 内的所有数的和
$ k1 X; w- W9 h6 i" kcount=1
sum=0
for i in range(100) :
0 s' [: M2 f( _& W  [$ N    sum=sum+count
    count+=1
print(sum)

count=1
sum=0
while count<=100 :
    sum+=count
    count+=1
: ?- e/ G$ v, m% M" O0 b  e6 zprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' C' i1 F$ J7 }将小于 66 的值保存至第二个 key 的值中。
& |- k2 L/ Y  ?0 B4 a即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
6 J0 f, n5 U, Y5 }, Udic1={
: C9 r  Y! X7 n+ e& l3 ]( Y+ c! b    'max':[],
: U/ j5 j4 a5 C2 t    'min':[]
}
for i in li :
/ M8 g5 ]0 z/ @% G$ Y- D    if i <66 :
9 H5 c. \- z" K% _, x; e        dic1['min'].append(i)
    else:
5 p  E% i6 q  M4 `" w* p) }        dic1['max'].append(i)
4 b; w# j: T" u8 K8 R# rprint(dic1)
! l1 w- l. U) f7 a; T# {
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
6 N/ H0 S" B" d5 E5 ]