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

$ i6 l% z5 a5 \& M3 w6 Y) H; X4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

4 [9 U6 \) K3 l% @6 z+ E" a1 E5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

9 S# U" f  u4 Z& s8、如何查看变量在内存中的地址?
z=1
print(id(z))
3 w9 A; S6 Q1 ^. C6 a9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

# j1 J$ U' u. l# V3 d10、写代码
% L: ?! }$ u5 u& Y# m0 ]a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
* y( y9 L+ Z6 j; b$ D/ E  z5 jif name=='seven' and pwd=='123' :
    print('ok')
4 a0 N6 Y) t% v5 telse:
. I9 W( {! t9 O2 E. T. ^5 L1 ?/ x9 k    print('error')
. I( L" q( l5 K' c# P) r: O
) K+ f/ V# N- z; _+ |" e1 k3 Ub.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
8 q  K5 v) U& ~count=1
while count<=3 :
    name = input('name:').strip()
8 f; T( t- t8 @: F    pwd = input('pwd：').strip()
2 G9 f5 M; E" {
$ `1 Q, N' C5 p$ s, f    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
6 R2 Q. a0 a9 K+ |% n        count += 1
8 J2 Q; v8 ~0 V$ \5 b3 ?for循环：
2 ^; b9 J( s& o+ R# |8 S9 ]7 lfor count in range(3) :
/ _3 |. ]3 Q& U$ G6 {' `. r    name = input('name:').strip()
+ {3 _% h& q; f1 \/ j& K' ]    pwd = input('pwd：').strip()

' y+ M3 U& g- S+ x    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
) F1 R) f+ }4 o        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
0 o. k% q+ @# ]7 L- bwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
/ r6 }7 x; l/ w3 N5 z7 W    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  s& ~" z) r& l* z% f        print('ok')
7 x9 j6 Y# j% t7 w0 P    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
; N2 p2 L5 J4 v    name = input('name: ')
( S8 N9 g. O* S) L; n    pwd = input('pwd: ')
! A  s* B  F9 h    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
& z  z' r' v# U% Z6 ?( l; |6 j        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
9 U8 W- C  X7 I! O6 y& Ecount=2
num=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
: e% E1 a, L5 P) d+ X5 K        count+=1
    else:
+ t( T+ f9 M6 x' E# E4 K( E% |        num=num-count
6 j/ U; y. c( I        count+=1
6 D5 U. v. N/ C& J6 _8 c0 hprint(num)

  S6 m4 y8 w8 ?4 G: s$ U, ?( Jb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
5 L( G8 a4 A" i% Y) d6 ucount=1
+ v. k8 Q- S7 mfor count in range(100) :
' E" X! A" P( [    if count % 2 == 0 :
        num=num - count
. x: p. ~8 q  r# |% s# S. l    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 :
( ?! \9 P" F+ H+ E        if count !=10 :
            print(count)
/ w4 S' u  t3 I8 ?* x! ?6 Y7 G; e3 \
5 d- }% i; [  P6 d& f    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
* R) p5 g* k# S: w. A# qfor i in range(101) :
4 d+ R" |' Y$ W8 C( I% _    if i %2 != 0 :
        print(i)
- M, |& j" X0 p! i7 U
count=0
: K" b7 t6 G% f) t# Jwhile count<100 :
    if count %2 != 0 :
        print(count)
! b5 Y$ s$ K) ?. d8 m" `( o    count += 1
% d) O, A* i" I) r/ M/ y
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* o* f& \$ U0 r/ D5 ^- ?    if i %2 == 0:
  ]; D6 G0 U2 B8 K; g        print(i)
* v  D4 i: U: m& ~9 `
; Z% s2 {# F+ r4 ]3 P# Ccount=0
& @% i. W) w& |3 ~/ P" jwhile count<100 :
$ }3 F) o! S5 z8 a) o( ~    if count%2 == 0 :
        print(count)
    count+=1
1 A# D, j0 j$ t9 H6 m
12、分别书写数字 5，10，32，7 的二进制表示

0 Y* U* E* v1 S5 z' o' W+ V0 X# cprint(bin(5))二进制   0b101
9 L, a  R6 J& ]" L8 @print(hex(10))十六进制  0x5
# |5 {' J3 ~  a) ^) wprint(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

18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
- O/ v/ w2 l8 B* ^c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
) u5 S) F. T0 X! b7 ]9 c! eprint(name.replace('l','p'))   apex  
. w& z- F% d( {0 x- {# \" U: qe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

6 B% J' G' n& i. B* Wg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
, k, b1 Y% ]9 J  ?: z6 X
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
. C& f$ P( Q0 o$ Y  Q依赖索引
7 o' U: w6 w* P- X; G# N# Sname = "Alex  "
1 f' z' W6 F/ b# M2 ifor i in range(len(name)) :
1 L1 J% f. e7 V( |' s: Y    print(name)
! `( Q  e$ K5 R, g4 v% m9 R( gfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
5 W! e8 g) n. @/ `% x! J' I3 U22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
( o# K0 B7 N9 Pprint(li)
['alex', 'eric', 'rain', 'seven']
; ~$ x4 V% E" e9 |8 X; U" T3 x9 Xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
$ s0 E1 D. K% e3 T3 m( A; s% \- We. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
( `% `/ j/ J0 o8 bli.pop(1)
# A% n/ r  n/ g0 n7 Jprint(li)    ['alex', 'rain']
3 y) u9 d( Z2 {( @) S! G指名道姓的删除li = ['alex', 'eric', 'rain']
% k4 Z1 D: @% V/ Xli.remove('alex')
8 [2 J# v0 {$ ^3 S1 b; Yprint(li)
7 W  ~5 v+ o$ C) S+ |5 W+ M# Bf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
9 H" M/ R! G: F" c1 }; o! Oprint(li.pop(1))
print(li)

, |2 Z/ Y. x8 A% N7 I6 Zeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
5 x; i) k$ \4 q" Oprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, c2 E. w- w( z" y  Q# E6 P. Uli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
* l1 H5 v# b+ }/ x: T( Z    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( U3 G2 a0 K! F$ ]/ Ja. 请输出 “Kelly”
6 c& D+ t3 a4 p  C, r5 oli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  i/ g' S7 Z6 Q9 M$ F' d' vli[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; Z" d1 V3 X# X6 x; T/ j4 D7 E8 y2 j- ]print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
  p4 `9 g( F6 \3 k. j0 b4 Ifor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
, }' U4 R6 O) w1 Y9 ~6 J  T, |11 eric
12 rain

for k in enumerate(tu,10) :
5 Z# Z# i7 J6 v3 C, i, P9 D' J( P    print(k)
(10, 'alex')
' A" g9 t- F) Y. ](11, 'eric')
(12, 'rain')

$ A7 w( ^7 E! L! Y; W
3 {- w/ z& ~4 R25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% Z- ]# b6 ^/ j' gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
: R7 W* ^  A3 j. A  x+ m. Rres=tu[1][2]['k2'].append('seven')
& T- W7 x& R( N- o. ~2 A& C- Z$ G
print(tu)
26、字典
, A, r* @3 l: t6 ?7 fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
" q0 z) P+ [( w+ L& O    print(i)b. 请循环输出所有的 value
; k2 s) f# S( l( T) Tfor i in dic:
0 E2 e: b! N" S8 H; l    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
: Z9 F- K( e/ u- a# X& i5 t" Hprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
4 ~' g; `5 z) ?5 l7 w1 z- a+ Odic['k4']='v4'
print(dic)
; g) n9 y3 t. g  D* M' e0 f/ c1 re. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
( C. W) |. v, D$ k, G4 K3 M3 i
1 v  S4 t  O3 _6 f* a  p/ R! g0 bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
5 K9 Q" F( n; Q( N: Gdic['k3'].insert(0,44)
2 T! W: {1 A. K: T' yprint(dic)
27、转换
, D. l. l: I+ g9 J& }a. 将字符串 s = "alex" 转换成列表  s = "alex"

# t5 C- h* G& v* j  eprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
$ L9 B3 u- b. `) s; y" h! Cprint(tuple(s))

, a( ~; i; D9 l% I% j( w/ K5 db. 将列表 li = ["alex", "seven"] 转换成元组
( G6 Y7 {( J9 Nli = ["alex", "seven"]
$ |3 `4 i5 G( _print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
( e# E3 q$ y7 uprint(li)
4 t* z# s% d, X

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# Y- `& l" B6 G& N, S% f9 ~
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) s7 g9 n/ F* A5 B6 q6 u0 f* Va=n.encode('utf-8')   
print(a)
" _2 r$ n" G$ K7 z9 _& g  R: Mb=a.decode('utf-8')
4 I. z( m/ [8 J+ Z" |2 K4 Z0 ~# y5 I% K; S! tprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
, x% Y1 @% e# J5 g& c6 C    count+=1
3 s! B6 u' o. yprint(sum)

" n0 b- {5 |7 [0 a0 Ocount=1
sum=0
5 Q" |8 U6 g, F; e9 m  [# Hwhile count<=100 :
    sum+=count
    count+=1
$ ~3 Q' H: o8 u) n* u; Jprint(sum)29、元素分类
) z. ?5 h- O" r+ i9 E有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
8 Z# s% z" H6 l5 I+ Ali=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
2 d0 A, T, S3 g5 U' T}
3 D0 I; y5 B3 R0 Z7 c: Lfor i in li :
    if i <66 :
- e' V  ]# U; N        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
* q* c& R' }/ C% {7 t. i
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
" e; U# `: {& {& h, o, Z