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

5 k, W3 i; a: m& I( F! G* X) c4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

& Y7 K$ a& g0 f* Y6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

4 H% j- _* Y! Z: |( N. W0 u8、如何查看变量在内存中的地址?
& N8 W+ Y0 u, Kz=1
print(id(z))
' `8 L/ R6 }) T" F9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
* Q$ v* j8 i6 @1 d4 M; A7 T  L+ qa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
2 b& r  M& a- t& o' B( U* ^if name=='seven' and pwd=='123' :
    print('ok')
$ K  \/ O' u" c9 d8 [" [else:
8 S2 t9 [- l& x( j% g* O    print('error')
. `1 b# ~. b. V6 x# i. |
, T% v# H/ a  X4 z0 kb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
# E5 K" s  ~' a2 M/ ~* R- vcount=1
) {$ H+ r, L5 Awhile count<=3 :
2 v7 j; F* U. V# d    name = input('name:').strip()
    pwd = input('pwd：').strip()
3 C. ~- {3 T+ p# O7 a
! G7 K) x! E- N. r- [    if name=='seven' and pwd=='123' :
& u: q; s6 i, r& ^/ A        print('ok')
9 S. j+ S% s, i1 r, R    else:
        print('error')
        count += 1
! }6 U0 v- n) n* A& P1 K" z# k/ ffor循环：
for count in range(3) :
( k% p9 L; T% }0 K' w, C: |0 s: V    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
4 m/ @1 H6 D% V        print('ok')
    else:
        print('error')
- m) i4 S1 G5 z1 v* a! U3 p        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
1 ^; g/ T2 {! ^- Mwhile count<=3 :
    name = input('name: ')
/ {" e) ]$ ~, p* A/ e    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
. l0 b& ^' ~9 m    else :
0 ~% P  w& |8 J4 Y+ h2 @        print('error')
4 K; A) Q" }+ \) U# @        count+=1
+ m6 b# i/ u# ?) X+ \5 q( z1 I( Bfor循环
. a! l& a6 D9 h% e5 u% \, x. ?for count in range(3)  :
    name = input('name: ')
! E+ G& ?; T# X7 y4 n  U    pwd = input('pwd: ')
/ V3 F6 i" D/ [# {. w# `7 }' a    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
" i1 `9 }; h/ y! s. v6 F    else :
' Q# P7 n+ A0 U5 o        print('error')
        count+=111、写代码
. F; Y- ], }5 M3 O1 i0 La. 使用while循环实现输出2-3+4-5+6...+100 的和
# h  w2 y- e, Dcount=2
num=0
% V9 _" [% m' P* X8 V' Wwhile count<=100 :
' A/ z4 I, N/ d. B$ e- K    if count % 2 ==0 :
7 a3 b; F6 h7 d9 g8 z9 {' N& _        num=count+num
        count+=1
* o5 r1 v, y* t8 M    else:
4 J( K+ O7 i* i! Q0 f        num=num-count
1 R. ]* l3 h9 {5 S        count+=1
print(num)
8 c" K9 g5 e1 G! f, r
( u; K5 T3 W2 @4 t( `7 p# ]b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
/ [+ ^& u4 N3 f' E( t+ @/ Y2 o num=0
count=1
for count in range(100) :
1 u* s3 b: e) ?9 `    if count % 2 == 0 :
3 a% j$ t7 \' Z) }; P! m; M4 z; p6 V        num=num - count
1 ^" @3 y" U" f9 a8 d    else :
        num=num+count
print(num)

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

count=1
while count < 13 :
    if count !=6 :
. _5 d8 r; X9 K/ G$ y6 w( Y" M        if count !=10 :
9 ]1 L! K+ s; _" M0 P            print(count)
$ L/ G% P5 ?; `; g
1 Q9 @, u8 K" f2 O    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
9 L# I4 s4 n; Z8 _  ]for i in range(101) :
1 j6 f( ]+ |; O2 z6 [    if i %2 != 0 :
/ D% A0 A1 U# N- S        print(i)
# I4 Y" w3 \: B  ?2 T& h+ v
1 p% P" t: q9 w% a; A) I6 W- ~4 ^count=0
& _; F; j* c" w1 ?3 q0 hwhile count<100 :
    if count %2 != 0 :
        print(count)
    count += 1

4 |2 Q7 h; ]0 [, y; v* S* le. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
" l- A! C( m- w- o# v5 u' Z- x        print(i)
8 A+ t: U% P+ \, V  _2 t/ b0 c
count=0
; [0 C) e! e9 b; ^; u/ Fwhile count<100 :
  g/ q% v0 _4 U* g1 M    if count%2 == 0 :
        print(count)
    count+=1
( w8 N( i1 C" q; T$ l" n* p* L3 `
12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
0 c3 `! j! z4 S: j5 fprint(hex(10))十六进制  0x5
! P5 `7 C) c0 C8 \print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

( B+ m8 e2 f, X7 i# k, \5 g7 K
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
3 P3 Q$ G5 P% `* ]a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
4 t: o+ ]7 ?3 A0 R' e
2 G3 p+ t/ h! k# [b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
6 }- N* R: t' ?print(name.startswith('al'))
% f+ e& g+ U% b2 C' U& [c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
4 e- J& A% f2 y, G& c2 Sd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
3 |8 V* Z, J( L! n" B+ l4 b; R- C2 [
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

: P- g* Q% U, X7 O( Gj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
! [: S* k- S3 n( i. e2 `: P  |8 j依赖索引
name = "Alex  "
, v* n( a$ [5 y8 _  Ifor i in range(len(name)) :
$ C$ D9 M, I3 Y. `0 }& u    print(name)
for i in name:
' ^( _. v, I% c9 T- w    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 N2 t0 n7 w( A" L( ^3 k+ w. o- Zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
* i2 u7 ~0 \) W8 I7 ^. Oprint(li)
['alex', 'eric', 'rain', 'seven']
" N; l0 d- c6 S8 B" _  A* Bc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
+ B6 D: i; ]& M* A* k8 N% U5 Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
6 x( t  g3 r! P& Hprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
' Z0 V) x. ~: C( L* K" Z  t. \print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
  B/ L6 I0 V  s* \2 }$ E$ S% pli.remove('alex')
' [$ c9 S" P6 g1 X7 p  S0 P1 fprint(li)
) h. O8 d, @( Q0 X" Jf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! a% Q; [0 T: e6 \& p$ t) \print(li.pop(1))
- S2 ]% z$ c; J) e8 P$ E5 M! j8 ~print(li)

eric
+ g) T% r! Z2 _- |- s+ j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
7 z9 |9 I; Q: c/ O" q+ u# u1 Z& Ydel li[1:]
" m) X7 K0 g2 \8 g/ s) b4 b5 ]print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
" z2 x' W2 \) U( T2 p5 hfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 T. j$ h: F: Qa. 请输出 “Kelly”
' ]# Q8 m8 F  u8 e6 wli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! @  i* P9 T. zprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, }  e! l' P8 x6 G9 Kli[2][2]='ALL'
print(li)
6 w4 w4 I: T9 r9 e) b0 }1 v24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 N3 Q) k3 H7 r( c+ Q: {4 na. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
7 i" S; b' L$ x' @$ l& R    print(k,v)
' ?8 [$ U* L' ]  _7 j, i! C0 J10 alex
: L. Q9 [7 `) ?11 eric
12 rain
3 k$ [) e* k# ^- h( b% `8 }3 n' V
2 f$ |" g; n- U# ^" Q9 I3 `; L; Nfor k in enumerate(tu,10) :
    print(k)
7 d! e; ]6 W0 `3 q) O. C+ X3 K* W(10, 'alex')
(11, 'eric')
9 l) G: M/ \7 y: s4 Y3 o' x& o' j(12, 'rain')


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

元组，不可以

; O- Q% G1 B& V* bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
* E: \0 L4 U6 \6 Z4 R: r' M8 mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
5 m( K! S# l( T5 A/ S& }$ w7 J* Q$ C) ores=tu[1][2]['k2'].append('seven')

, |6 ^3 y; O2 r, [  Z1 O) ]print(tu)
. U8 d4 ^# B) s! ^! Z% ^26、字典
4 \7 {) D8 W' ]dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
/ `( I8 P3 F# {8 E1 D- K. V. Z    print(i)b. 请循环输出所有的 value
- ?- y4 C# ?: m: pfor i in dic:
6 e: b- Y6 j; p3 u0 @% i    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
$ Y; P7 ~' N/ k$ vd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
/ ~1 Y7 K3 H& [: je. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
6 W  b6 [# T" hdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
  ?2 x- K1 i) i/ e& ~. {/ V. }3 i
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
  n8 V5 P' X' \0 K27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

1 J, L7 M5 r- O- f+ }print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
0 @4 C& v4 J6 R; S, S7 cprint(tuple(s))
  r3 r% v/ Y% x4 V- Q
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
! `" {* B+ ?) R( y( ^print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
/ D% O1 q8 b! z% P# Uprint(li)

" [7 m! }0 y% Q) ^
2 k% y& _& \! n7 Ad. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. d* c( \/ z; p* N6 c
  H( I  K* F& n  `0 x& S. Mdic={}
& C! g" S" {7 h* m3 J$ J3 ^6 afor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
6 R7 H6 N0 r1 g# R# _7 E& c+ O# wprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
# ]6 e( {5 a6 Ab=a.decode('gbk')
7 k% h3 D6 L' z$ ?$ qprint(b)28、求 1-100 内的所有数的和
  `; i. f* w* M# _1 a/ U% S: n; Ncount=1
sum=0
( Z' o4 W; F5 Afor i in range(100) :
6 |2 D4 ]3 h! V    sum=sum+count
& b; o/ M& t- }0 a1 _    count+=1
print(sum)
6 q: G0 d6 z1 X9 n& z; d& A+ E
4 b7 h0 r/ l1 a# E, L; y+ ]8 icount=1
sum=0
- p; a- l/ G) g& @while count<=100 :
    sum+=count
    count+=1
0 \  w6 ]5 o9 ^5 N  l- Eprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% ~  D5 j- T# a将小于 66 的值保存至第二个 key 的值中。
+ M- x. ?) n" M3 O即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
" S, T& F& J) ^% l) ]$ J, Y! I    'max':[],
( P. d# f) O% ]: e' O" w    'min':[]
}
* A. \' M% h: f( J/ d  b* k- _for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)

7 T6 l/ N7 d- e---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}