Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

( N, s4 e" S$ M# d3、简述 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个字节代表一个字符，

8 N! K% t+ o5 I. U" a+ J# \3 r* L4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

( u: `9 d% W: q3 |5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
8 J6 X% h" h0 A9 ]: G/ jz=1
+ ?8 ]& l; u5 m5 U3 dprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
8 `) [& u5 i7 F( n6 W+ aa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
, O; X( A& e& B0 @" M* }    print('ok')
) [& Q8 A! G$ P+ _7 M3 Aelse:
    print('error')

& i0 r4 x4 j" b: Q2 G& Hb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
( [% x/ J0 `0 A3 W3 Ucount=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
% N/ j  w/ P" F/ S7 b! Q; H        print('ok')
    else:
        print('error')
, Q; m' Q$ J. f3 ?  d8 _, l* a        count += 1
8 E( Q4 f7 A7 d( f8 x& O, k+ J6 Hfor循环：
for count in range(3) :
! [9 m, |# N1 T) a0 N    name = input('name:').strip()
    pwd = input('pwd：').strip()
$ U8 M- n# W5 A  r8 k
; U+ G+ s6 }3 w4 X. B$ M' k  \    if name=='seven' and pwd=='123' :
1 o4 g/ K& e$ s8 b# h) N        print('ok')
    else:
0 Q2 x, i# o4 Q+ o6 {3 x        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
! T  B0 n) m# xcount =1
+ |! q$ v- A% U4 ewhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
- _& v" \8 ^, `9 V- t) @& X    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
' R6 f9 B6 u! U+ t! l    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
$ k0 H, B( U+ l# T9 I/ D1 J5 _) H    else :
        print('error')
        count+=111、写代码
& R% w. O  W! P  K4 P; [0 ]a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
' l$ M& A  }& M2 d# U$ R3 owhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
print(num)

1 f/ T; D2 `4 a* t1 w7 Sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
) M* K* }8 \; q2 k8 A num=0
: ]! {& a0 _! d3 xcount=1
for count in range(100) :
    if count % 2 == 0 :
  o) G7 B8 c" K! L; g2 V. \* O        num=num - count
    else :
        num=num+count
* |. h" e+ }! c7 v4 a5 F9 Aprint(num)

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

+ e; u0 z& f- n& f7 f) dcount=1
while count < 13 :
+ D1 z/ P% Z+ `4 `    if count !=6 :
        if count !=10 :
1 K# I0 U0 l) A9 m/ E8 m            print(count)

; q8 d6 ^6 y% R$ }) T: R    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

- B: ?+ N0 m5 U( I  `# D/ a2 Kcount=0
, G: ?2 w  r9 H3 zwhile count<100 :
    if count %2 != 0 :
        print(count)
* C' G! j; b0 M; X+ x. v    count += 1
$ m, b& U0 d5 [+ _0 p1 \( w
/ ~7 z5 F3 R* }3 `e. 使用 while 循环实现输出 1-100 内的所有偶数
7 i/ W6 a" d$ Jfor i in range(100) :
    if i %2 == 0:
6 ^$ o, U5 L& J) `        print(i)

; _; c- t" ~( {6 m& z* Z" vcount=0
- V) L' b8 a# V! `4 Uwhile count<100 :
    if count%2 == 0 :
        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

' l# a; O; u9 s2 {) E+ k: Uprint(bin(5))二进制   0b101
1 z& X" J/ Y" @$ P/ Vprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
$ s% y8 o9 ]) g& e* I8 {14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

6 U, j+ I, m# ^! Q* f5 q16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
  K+ Y+ U$ w+ z1 w( I# G! z17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
0 w# B. A- N. W4 h4 i* B; d# d, eprint(int.bit_length(n1))  结果  3

/ n' @6 H1 \6 e2 B3 I  ?18、布尔值分别有什么?

False .Ture ,或1  和0

1 H2 r% t) u& R9 k5 H9 p  G20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
; b$ m1 N" f- i: B" t
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, s. h5 s+ @% z- S) o# E4 z% o' @* gd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
3 r. ~8 J2 s( ?! }print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
* a4 E7 J* ~" W: c- `' Oprint(name.split('e'))   ['al', 'x  ']  列表
0 [, Y2 G8 J. n  V6 {9 O- L" W
  Q+ c: T( [! y1 dg. 将 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'))
! D0 |3 N! ^* H+ U5 j% T21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
" m$ u* e: Y, Z; P4 F9 Tfor i in range(len(name)) :
2 M) @3 I3 i; d1 x    print(name)
$ }! N  R9 Z3 v' H5 \1 a& U& `for i in name:
0 E; S2 _2 Q+ F0 a) [0 b+ z: |$ j    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
( J# ?1 a/ z0 ~% @7 G- S22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
4 p* a0 l- c/ Y8 X  rprint(li)
  ^5 ?5 X# ]" a7 @& g) {$ F ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 S* r& F1 |- t2 ~print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
% J: J5 L( l& z" _0 \& K2 Zli.pop(1)
. ^+ E" \; S) i4 ~print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
; Q* b$ c+ V$ Z5 @* j( Q6 gprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
6 q4 N; o! R  U! n) z, i
eric
1 t0 U7 C# x% F$ w['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) q) G) F0 d7 _7 H2 L5 \" Idel li[1:]
; P' O# q+ V1 r) N  {# p: sprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
4 x7 c" i( I( Y8 t& Hli = ['alex', 'eric', 'rain']
& M1 Z; ]4 `$ J0 E' A' S4 yfor k,v in enumerate(li,1):
% n7 c2 G) P% S5 [: G$ K    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 ^7 d9 v; q$ i$ H% G) [- V0 Xa. 请输出 “Kelly”
& Z) [6 R& N/ v* B7 t6 }6 wli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
) T2 S  j9 _/ j; m7 ?: w0 h8 T4 \$ aprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
: `, z0 N* b. @4 b8 |" T% xa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
- {  `- s  ?* A4 nprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
; E' V$ t( r1 N5 Ve. 请使用 for、len、range 输出元组的索引
7 S: N9 ]4 h$ D8 b( efor i in range(len(tu)) :
. r# E6 Y1 R1 [0 |/ @& ?    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
1 [8 Z: f& \% J: `8 h- x; ^    print(k,v)
- F/ Q3 ?# J/ c! E) H10 alex
11 eric
12 rain
6 f1 {$ \5 ]+ i$ Q: T: Z
) {  x: ~( v5 h  L+ j; [for k in enumerate(tu,10) :
    print(k)
, Y, C  z: H6 P7 Y+ r" y(10, 'alex')
(11, 'eric')
- i3 O: T! h4 m2 y0 b(12, 'rain')


6 J+ p9 ~* q' z9 h' E& u! Z2 `$ i25、有如下变量，请实现要求的功能
6 w% R* w4 o  R! v4 ?5 q6 r: |( ytu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: v' ]6 Y) `4 L! D* Ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
, ?" x1 p% X4 L9 M8 O# B7 P4 W! tres=tu[1][2]['k2'].append('seven')

print(tu)
8 Y$ u6 O8 y3 |26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
/ O, D2 K2 U6 u1 ~& z% c    print(dic)
! ^8 r) B, c2 q4 Q" k% s; cc. 请循环输出所有的 key 和 valuefor i in dic:
: p2 t1 U$ J: N3 _print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
1 [+ P3 X  ^8 I, T, fprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
' Y, B, G( V. g% V' ?6 [print(dic)
0 ]2 j6 `6 J7 m( |+ W. p) b5 w
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

. A+ o5 x( J% Y1 V' Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
0 G7 k9 b( g# H. k4 X( d2 L4 t+ {# aprint(tuple(s))
9 `! a4 D9 Q" J' ?7 A
% E0 M5 z  h5 q3 L2 A! @: I( ob. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
" Z; q7 @: I3 vli=list(tu)
print(li)

6 `3 c3 Y0 {4 \+ m9 n- m
" P$ ~0 r1 s. u) e3 f6 ^d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- c* m& z. X/ u! B: B; n# z
dic={}
2 n, t- x! c, H* X0 xfor 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')   
1 h9 V& a# G* |* v# g9 s  X$ F% lprint(a)
: ^1 ?, M* @! p" s, @6 H% I  T) Pb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
9 F5 T. g3 U/ W8 X, uprint(a)
. o: E4 ^5 e* I% E" |7 I1 jb=a.decode('gbk')
! M* F$ ~9 \4 Z5 z9 Bprint(b)28、求 1-100 内的所有数的和
0 [! L4 |: ]9 M# ~count=1
; G9 S1 H$ E6 H$ I; q7 rsum=0
6 i* G+ G' o3 ~8 u+ Kfor i in range(100) :
9 J. \0 a3 n9 B    sum=sum+count
: ~+ V$ D0 r& J* C8 [0 F4 V& c' D# h    count+=1
9 X8 u/ }$ I' Iprint(sum)

/ u/ H9 S0 Z/ i6 z( Ccount=1
sum=0
while count<=100 :
- d& z) ~5 q! n+ N$ Z5 ~    sum+=count
2 X9 t3 l/ e% N    count+=1
# ]3 L7 ~, t2 lprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
1 F5 ^0 S$ ]+ Uli=[11,22,33,44,55,66,77,88,99,90]
" h( ^7 b3 s. S& Q) Gdic1={
    'max':[],
    'min':[]
" Q3 l$ a" L: k/ i}
for i in li :
. {9 M2 k+ L& x% S% ?    if i <66 :
        dic1['min'].append(i)
8 F' l) P0 b6 x$ I3 P4 N    else:
7 l/ a, u4 N1 D: D        dic1['max'].append(i)
print(dic1)
; C. u# K0 Q! v+ S! U% O( h
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}