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

1 Z: U3 c, H# K" {4 H: r2 t% i4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
# l. W, u9 x$ f7 y0 x  C! I- eprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
' b! K. _( r5 J& e8 Iname=input('name:').strip()
& @9 \- N/ z9 d2 ^- E6 vpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
5 G$ z1 W! {  c$ N8 V    print('ok')
$ ]; p$ p  h) `5 k+ ?! i9 W) nelse:
    print('error')
, f, _. x7 m% w
0 }# O7 D  m2 Q; L" ^; n4 k! Vb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
8 h' L. N  r! H% e' w! c) Jcount=1
while count<=3 :
& q0 O1 ~' p% n3 N7 E1 E    name = input('name:').strip()
    pwd = input('pwd：').strip()
' @# N/ I3 L4 _! B2 C/ \# |
: X2 g( m# e1 L' |    if name=='seven' and pwd=='123' :
        print('ok')
    else:
6 C) B& x$ ]9 Z8 m2 S! C2 P        print('error')
. z7 ~# k8 T/ b8 h0 I, i        count += 1
for循环：
for count in range(3) :
. l1 D7 r% V" _$ ?1 \    name = input('name:').strip()
. g% ~  T6 U* s9 I) U& J9 N; s$ B    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
! _, k1 o7 h2 O; F/ N    else:
6 q! O! y! k- g$ \* l        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
) `) d, l1 ~; y$ ^- u( Lcount =1
while count<=3 :
8 w, o9 t" [  R" ?* k  V0 u    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
* n/ ?/ S8 `) Y7 x1 B# b        print('ok')
( d% l6 C3 j% `    else :
) ~0 a# \8 ~5 @" W! u; A        print('error')
        count+=1
' k* k: r" r! T) ~for循环
% t. L# G( ~  ?. a% _: g# ]for count in range(3)  :
    name = input('name: ')
+ X1 i% K2 e# J# j+ |4 ?# r    pwd = input('pwd: ')
# v2 ~: V( B+ D    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. o% S( Y3 i: P* ~& M3 F3 i        print('ok')
; h" B- D  c, Z3 j5 g8 |8 h    else :
4 F1 D6 |" q' i  F8 p8 v& {; J        print('error')
- G' F& B) f5 F" p5 L        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
0 s- K- }% \7 Q8 U4 N% ywhile count<=100 :
6 \& ]$ _1 `3 s4 U0 R# Z. L    if count % 2 ==0 :
        num=count+num
# ^- U+ O2 S5 M8 k% i; W        count+=1
+ m3 \% |1 w+ e+ L( u4 f    else:
, @3 [& v9 f( @        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
: e1 K- y2 H0 W num=0
3 @$ J' Z1 M4 mcount=1
3 o' x1 w) z* [, y- M! W/ ]5 e& X  Ufor count in range(100) :
! T/ K# T( [9 H6 ?# Q+ T, O* c    if count % 2 == 0 :
& H. S# [2 j5 K- w        num=num - count
    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 H' w4 @$ y' ^        if count !=10 :
9 T" q$ a, k5 a4 U# L3 y2 E0 o$ D$ Z            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
+ J1 _! {9 ^  }( }: b8 G: I4 D2 v9 x& Ufor i in range(101) :
    if i %2 != 0 :
+ |* b# Q( T, Z2 Z2 |2 B& o; w        print(i)

count=0
8 \5 _8 b  a* }; K+ K7 S$ n5 _while count<100 :
# c& ~; o9 F5 Y7 G9 c1 `0 ]    if count %2 != 0 :
        print(count)
8 K& G' d0 r0 u+ j* Y    count += 1

) W2 J. q; n" R% X5 m6 re. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
; E" H' P/ O8 X        print(i)

8 v. ^7 [( [, N  l( ~: Jcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
1 y# U1 n$ v0 R8 `  Z, a    count+=1

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

( o" |) p: |- m- G+ tprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
/ L4 x- W1 s8 _/ C8 Q  ?* E" Sprint(oct(5))  八进制  0o5
# z" }  Z. E0 s% ^# _; K; N4 b14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

4 N, o6 N) B+ C# U% {8 A" f16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
6 I2 R' m& o5 E5 ^" q17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
0 V9 E/ R" J2 b- u: H5 j3 r; O- |print(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

8 z* }5 F+ I6 }  a) N- e" y20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
& F2 k* X3 i) A) ]# k6 [* L% k& _a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
( f9 A: d) G& \# zc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
4 c' k5 A% w2 X5 |  ]d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
4 k5 n! }7 O6 K/ ~; {print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
' M* |6 @" A# S$ W. }; t
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
5 f' i% K1 A; c/ j2 Y2 J; u# y
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
# i. I: N* I# `for i in range(len(name)) :
" L# ~- q  y$ S3 o    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
4 ^8 l1 g+ U) B) I! s# C# Y22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
$ v- i" F- r& r* i3 s) Hprint(li)
['alex', 'eric', 'rain', 'seven']
$ A; ^# F' A' G9 @; O; Q. |1 ^c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
( q7 t% T( o4 X) `* a/ dprint(li)
/ m- c, h( v5 U  a/ Ie. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# n$ D9 w% ?2 m) b! D8 X  M1 @+ Gli.pop(1)
3 q  d( @! v! ^, I; H! ~, P+ Zprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
% v2 i+ L% ]" a( ^print(li)
* ]' @2 r7 o# Q" ?0 K
( n; k  A+ Y/ s" @& _  k. q( {8 oeric
' O, j$ J4 S! \- H['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
! S9 ^; L" j9 x' G4 Fprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, q1 f$ v; v9 ^li = ['alex', 'eric', 'rain']
. Y, |% O6 T5 @7 M+ pfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 y- j  G% j5 r4 ?5 x7 ya. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 J1 G! M. a$ E- {3 x5 U( cprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  q4 e/ N6 U2 f- Gli[2][2]='ALL'
9 M; o2 j6 s; m  oprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* @$ O# B" C4 P5 S' nprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
1 ?: I3 u! f+ A  z1 |0 |, u! Ye. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
6 R; N- A  Q1 l! B& a& ]    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
8 X( {  t% {$ \6 Q& [( v7 V10 alex
11 eric
12 rain

! G, `, }' j# }3 d) ~for k in enumerate(tu,10) :
    print(k)
% y) y7 Z7 ^; `) L& Z. b(10, 'alex')
(11, 'eric')
, m. ?$ `- E* ?* u(12, 'rain')
" w' u# e3 \# i) E; T

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

元组，不可以

1 F0 b1 j( D  V' C/ }  Yd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
  d+ w, [- N0 E9 B. l; E
print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
% A+ |0 p: V+ N8 W" ffor i in dic:
    print(dic)
8 w; O8 q8 C5 q( L& qc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
$ l& L7 Z; n9 y5 K: _, od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
. w" j4 C! l/ p; k  O5 V$ Fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
" t6 b; r" I7 c. h; D* |) g6 gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& _- o( `7 |$ r8 Z# Udic['k3'].append(44)
. {, F5 g$ s4 K6 _. oprint(dic)
' ?' _  f7 q1 u- F4 T! d, ^8 g
: o+ Y* U6 n. j2 C' B1 k8 kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
) z9 q% k; k8 C# u+ b' sdic['k3'].insert(0,44)
print(dic)
27、转换
/ v' ^7 w& o8 h4 n" W8 c2 W8 c" V. La. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
: O. i9 _; u3 u' us = "alex"
* r! Y; g) @3 l! ?7 s1 x# uprint(tuple(s))
+ D" r9 E! f( Y( x. `1 L0 n
b. 将列表 li = ["alex", "seven"] 转换成元组
9 [& d3 _4 i/ H0 ^% o6 z& e% kli = ["alex", "seven"]
( I# W& I+ e: b: o9 y7 gprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
& j7 r4 ]$ w& qtu = ('Alex', "seven")
7 O4 h' _. y9 P& ili=list(tu)
print(li)
3 ]# z+ K0 u, Q  w- E

- F% r& @$ O' Pd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: A( q/ d! q. v) V# N
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! T$ m& y7 i3 u9 q/ V* @0 S& ja=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
/ k2 u1 l5 C- Yb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
5 X1 F5 N3 N3 [$ ]- [+ j9 Vprint(a)
, d' u2 v7 @/ h' ?* kb=a.decode('gbk')
1 G1 n. ?. S* H, e9 e% G1 q4 _1 q: Pprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
. Q; J8 K+ J" h" b9 J! {0 C2 V    count+=1
% A1 _" l0 ^# O. s6 a" vprint(sum)

$ `, S  _, Z2 ~0 Y7 P% T  Vcount=1
sum=0
while count<=100 :
    sum+=count
    count+=1
0 Y1 x# O+ {* i0 Pprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% Y0 p9 R) {/ X0 x将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
4 _" g5 g: v7 b# E+ V, F# z' l    'min':[]
: {, R/ v$ t/ b* O9 l* N}
4 x. g- G  M1 a. Y. b' A- Nfor i in li :
9 q( r' T9 w9 O/ ]5 Y5 z    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
2 Z5 b3 T" B& z( [% O# X5 V& uprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) R! ?" I% e; n- j9 e: O: a( e, K) _