Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

# p' u1 Y' W: _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

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

6 D% @8 \' t5 K4 A) Z( T) m# ?8、如何查看变量在内存中的地址?
z=1
print(id(z))
* w4 `1 e2 p/ T. i9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
) v$ [& d7 G4 r6 g3 [7 H) Aname=input('name:').strip()
& a* B. E; r; o0 q+ [, R+ O6 bpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
) r9 I. M% Y, helse:
    print('error')
# u  r# R6 b' x+ F% C2 q; n! q/ u
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
1 `$ j, j8 N( C* e# b
3 }; h7 F3 \$ @, C    if name=='seven' and pwd=='123' :
1 }2 X/ u) K: b& C$ a8 V2 O        print('ok')
) F4 t- g# {& A: a, A- H    else:
: c" ]+ ~, R3 ~- O1 N0 Y* Y        print('error')
        count += 1
for循环：
' g( b$ \$ O0 k* xfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

0 s: `/ z0 U. _; v/ M4 _, e    if name=='seven' and pwd=='123' :
" R% o6 n6 t8 p. Y        print('ok')
" L' Q" O/ l% P! F    else:
        print('error')
$ D$ ]3 ~' O/ {8 J0 B* U        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
- ]- v" S8 S! L5 d1 B0 C; Rcount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' h6 [! N, q" `# T        print('ok')
5 y0 V( Y* X4 b9 p: q    else :
* E/ z$ c3 b; D7 h* ^        print('error')
        count+=1
for循环
2 ~) j. @1 _" g( K1 Y4 d( m; lfor count in range(3)  :
    name = input('name: ')
3 `/ ~+ A% Q/ s3 V    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
) c7 [+ P8 C3 p. L$ a; u% s0 g    else :
/ v5 O6 @# X/ k9 U% D+ e/ \! `        print('error')
* r6 \& L" {! p( B8 e        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
8 D/ `# i8 N6 o9 K1 R% N6 Ewhile count<=100 :
: z) x" C6 ?. k# P. g+ R* J1 _    if count % 2 ==0 :
5 z  F; E7 U/ M3 U: y; g+ v$ {        num=count+num
( m  E  N8 V4 Z        count+=1
2 D  m* Z9 U/ e0 p% T$ u    else:
        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
9 E: F. Q& A# _6 B/ B num=0
count=1
% s, c# o1 L5 \  I5 m* Y% ]for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
# o. c7 y1 D" i& V        num=num+count
3 K1 _, S, _1 j- _- v( Kprint(num)

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

+ N  K" u5 Q' Hcount=1
8 m2 k4 V% V- _" G4 Hwhile count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
! M4 S* i/ b6 {  E9 {4 Z
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
- ^" @3 q" V$ l3 t    if i %2 != 0 :
' X# n3 `- f( Q" y+ X        print(i)

count=0
2 F& T8 O& ]5 W! Ewhile count<100 :
4 S4 T8 w+ S# x4 v- ~    if count %2 != 0 :
        print(count)
    count += 1
( Y3 o* Y5 f7 V. H' G3 D& K* b
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
7 W4 @& ^3 K% @5 J. B7 p# ]        print(i)
5 [1 W1 n9 ?1 E3 \
/ k6 Z% W8 X( e- rcount=0
' B  C$ }- h: C; G0 G* b& h' D; ~while count<100 :
    if count%2 == 0 :
" c" J% I% K8 X        print(count)
* ?$ T* {4 k6 d  `* u( B    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
+ Y: M, ^7 x8 |( w" [3 s
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
: `$ L2 c' B1 R7 l( {& H; A) w14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

# ^9 b" A7 T/ z9 s, e0 I5 b18、布尔值分别有什么?

False .Ture ,或1  和0

; ], w9 [' \6 r$ h8 Y; l20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
+ X$ }6 Q6 f& o9 S7 Ra. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
2 \4 ^6 x- q5 F3 @+ a+ Q
' `5 `. p8 t1 L$ J, }4 j/ Ab. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
% P+ X. y' H7 Q, F4 `( h& Zd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
, \5 ]2 V' O% f0 P* k8 x; \$ aprint(name.replace('l','p'))   apex  
( U9 p  f1 _! I( \e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
8 _# _0 a# h6 `" i' p5 R) Sprint(name.split('e'))   ['al', 'x  ']  列表
" j# M: q% I& j* z8 {
+ |, b& X7 `+ Y# y3 f' F1 }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'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
5 N1 ?9 p& \& d4 ^+ ]name = "Alex  "
for i in range(len(name)) :
/ e3 Q8 m3 r. o% z0 q7 s1 ~    print(name)
for i in name:
* L- C6 q3 v# O! H) J9 W    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
; m% n0 G1 e/ a3 i" a3 q$ `0 n( l22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
, f7 F. {, A% J  I/ D" `e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
, Q8 f7 [  A/ O, B* K- \: Eli.pop(1)
& D- T: x/ C2 ]1 D& M% uprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
) b1 N( f2 R  h! U' \3 _print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
5 I+ S2 A7 b# xprint(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 A/ m3 m) l, a9 N. e' `6 kdel li[1:]
* e3 S; `+ _, d9 |& vprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
# Y. i6 z2 u/ h: K. Lli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 Y0 @0 d1 n2 B; @; k  Oa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! O9 ?2 n+ z8 Yprint(li[2][1][1])
4 [9 z- G$ d* r( b1 k6 J$ \b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
' e  S5 x% u: H) b% Bli[2][2]='ALL'
print(li)
- F& S4 q& Y1 t4 P8 p( e! P+ R* d. O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
6 _& q8 ~. O6 R5 S5 Yprint(len(tu))
' I! H3 U( a9 J: Nb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
0 x% D- D+ }# N  ^  k2 ofor i in range(len(tu)) :
; ]/ N2 u7 _" r) O4 ]6 u    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: x7 A+ i: ?1 Bfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
/ D2 o4 F1 C6 R6 h! c11 eric
2 N/ w- A2 P8 g( U12 rain

0 d! w2 r& B+ }/ s. i+ Gfor k in enumerate(tu,10) :
9 z7 U8 j5 ]/ r    print(k)
(10, 'alex')
; I  Z4 y) l' r' R0 @$ K  |(11, 'eric')
(12, 'rain')

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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
) s6 M: R  _, W, G! A4 S: V0 Jtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! u, `' q$ E; R9 O3 zres=tu[1][2]['k2'].append('seven')
% B) J3 P; {2 M1 [6 T2 q" k1 u
print(tu)
, M/ a2 T1 s4 ~. ~- U2 }26、字典
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:
print(i,dic)
0 ]4 A; V. j6 s. Td. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
" J) e4 o8 p8 y  P3 V. Q5 x: Kdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) L( `) _% g) b. D2 F6 _dic['k1']='alex'
; v0 o% ^1 A; U+ A$ D3 q$ J. Nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
* s* j. G* W7 u. Bprint(dic)

' G( ?3 i% u0 e6 w0 Ag. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
9 V5 ^6 A. k  X5 ta. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
5 P6 \1 U6 m: w, s' H$ l8 U4 yprint(tuple(s))
* S  ~- c- r! v3 S
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
" ^( l6 Y  b/ g- H& xprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- N: t- y; G; ^$ A8 T5 M+ wtu = ('Alex', "seven")
/ ~# v0 f  @8 E- X' q. ^li=list(tu)
print(li)
  C/ \2 ?7 e" e

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

6 r* n. B* u# ]7 H  V. Zdic={}
. a0 p+ M" C7 Q3 J8 v% _3 r9 dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
& Z+ t3 P& k" r" [  i/ Z: c' }. @    print(dic)27、转码n = "老男孩"
; R( v$ H9 @* h& {& u5 \( t' ma. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) I2 Q5 o' @. K) ?* ja=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
6 K- O# P3 r4 u- Xprint(b)
: `$ T0 T* c: ab. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
  A! {6 x7 @, Gprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
. d7 j7 Z- J: C1 `$ I6 U* ^8 T( C    sum=sum+count
    count+=1
print(sum)
6 W7 U, X% q$ _4 Y/ A
" b: C3 q4 i# V0 Xcount=1
sum=0
3 v( P: Z. ~7 s, }+ uwhile count<=100 :
3 b; `+ ^7 A. i$ o  s& x    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
0 a  G4 i$ W! G% h; ^, ~$ S* L将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
# P9 i+ y" i6 d: ]li=[11,22,33,44,55,66,77,88,99,90]
4 h% q% w0 L9 N3 s/ fdic1={
    'max':[],
5 g$ F/ E) B  b# z  B( ?    'min':[]
}
9 P. Y) j2 Q+ \8 [: }( [% kfor i in li :
" M3 W! }* m6 Z    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
+ N3 Y) v  C$ `print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
& j$ i$ u) S" u3 L. n