Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

8 N. a# n& Q: z3、简述 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

3 f# T! y! W) p$ p+ ?5 d5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

$ ^) G7 s1 |% `) M! \0 x8、如何查看变量在内存中的地址?
0 H% V/ `- K* ^, g; Z  ?! [( P1 Ez=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
. B9 q) q- s/ Y/ sif name=='seven' and pwd=='123' :
    print('ok')
& x6 {& n: ~1 ^7 L; E% Yelse:
    print('error')
8 R% ?- V6 E  ?* Y
; p5 O, `3 R* y5 X; Q* @b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
3 u4 \9 |$ G& ]6 C( Fcount=1
while count<=3 :
, a- d4 H- m/ ]4 w( j    name = input('name:').strip()
! A6 @9 h( ?( L, q    pwd = input('pwd：').strip()
6 I+ J& \# @+ c( K+ d+ J
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
for循环：
' b8 k- u, b* y4 m; \. |% Ffor count in range(3) :
    name = input('name:').strip()
( w3 |& G6 ?" g7 N! A2 G3 g    pwd = input('pwd：').strip()
  q2 ~. _+ ?& ~: S3 Z
' M# t# B- k4 L3 l3 m    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
5 O! q1 |7 z5 v7 G    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
" {  G# v! Y* s( h* b- e) R) I* _    else :
        print('error')
. R8 y. [1 u4 \9 R* O6 q) J        count+=1
for循环
0 i" r* g, K' v: T, cfor count in range(3)  :
    name = input('name: ')
$ a5 ^, B& J% A    pwd = input('pwd: ')
! e; `* r% N* N! B% M    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
( e" \; }, v" |* N, z* v: J        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
9 V& V7 ?; W2 q6 C. I! u5 k5 |6 wcount=2
! Z- R: ^* l8 W  ?num=0
while count<=100 :
( c: J( n) ~6 e6 M0 s6 Y2 j    if count % 2 ==0 :
        num=count+num
2 R) n, u! a3 l4 B. k" n        count+=1
) _/ |* T3 y7 y) }, h    else:
        num=num-count
. z2 ~  u& U; I* X5 }& m        count+=1
" q' f/ w# L- q# U* dprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
% G9 _; p( v/ @ num=0
count=1
( {4 I; _& b% T# e: Ifor count in range(100) :
    if count % 2 == 0 :
        num=num - count
/ m2 Y. ?0 J- `2 C' F( I6 v    else :
        num=num+count
print(num)

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

count=1
while count < 13 :
3 @5 H% x7 F. P: S1 e3 t$ o2 w    if count !=6 :
        if count !=10 :
$ `: m6 o: k1 x' d8 q            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
3 E8 ~& D; |" O. F    if i %2 != 0 :
        print(i)
8 g! w8 R( R$ z% H' Q
count=0
while count<100 :
7 C; F1 n0 e8 F0 e# p    if count %2 != 0 :
! h4 h2 _8 @" R9 Z. o& Y        print(count)
    count += 1
5 ^" ^3 F) g$ J9 d# P* ?
, u' g5 \0 d0 b3 _3 ]. c- v7 je. 使用 while 循环实现输出 1-100 内的所有偶数
$ n7 z4 S/ C5 J) J' hfor i in range(100) :
4 Z/ n0 O( G0 q( `    if i %2 == 0:
        print(i)

count=0
% _) U% l  t% G3 {while count<100 :
    if count%2 == 0 :
7 B% \! o5 m0 c/ R        print(count)
    count+=1
1 ?3 ^  @" b; C4 B  l
12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
& Z* K7 W, P5 f; v$ lprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

! K7 Y9 \# J/ q2 M- J, t% R1 f16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
& {  W- s9 s3 w$ G) n9 Y( z1 Aprint(int.bit_length(n1))  结果  3

% C# H' B6 }9 P- Q* w
* k! Q$ {, W/ d6 z18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
: |4 b5 c% t( T  N6 I+ ua. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
( W3 o3 }- \6 w  Y4 C) Q" Oprint(name.startswith('al'))
4 v- K: h9 i5 k6 c% ]7 f! B+ `" ic. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
) W  i: s- S$ C7 D& l2 nd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
; {' G" O! P( |print(name.split('e'))   ['al', 'x  ']  列表
! y: v( S8 K/ `
; K* k# p* Y4 `' \g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
# T- |& u$ S6 `% S  p: ?
4 Q% G' d# M& sj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
7 J/ _0 [. {; S4 a1 Y9 D( v$ V依赖索引
name = "Alex  "
for i in range(len(name)) :
, p5 }! ]1 j1 f0 }* V. B% z- K- k/ q    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
3 ~; ]3 c  ^- [) m) x" Pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
" }' N, d- r. W) i8 k9 Eprint(li)
['alex', 'eric', 'rain', 'seven']
+ e2 _) f" v  m. ~& Dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 `8 ]" z1 T9 L/ p1 N  C# Rprint(li)
* n" h; P% t+ j* s0 i7 a; re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 I& K7 l8 i2 }1 k" w/ dli.pop(1)
0 N7 W5 ]8 P, P; U8 Kprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
/ m: \* R* {7 H! a! @print(li.pop(1))
' [# o4 s& W. K! cprint(li)

! u* l( l; @- |+ Y) o9 Geric
3 w! y  E& k- y9 J3 t3 n7 N['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
& K0 }! F( N# `print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, W2 T& M6 h" Z% cli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
% s- ^$ d) d7 ?, a' H    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) e9 G1 @: N% M# f7 R. o0 {a. 请输出 “Kelly”
% R* }) z: S0 \% K9 ^7 Vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
5 K% T5 Z: ]( v  D8 `b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
# k) E$ ~9 @, J* O  u  p: aprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* x/ c. {  C5 ?# N; Oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" U8 w7 K& M. Y- w) Fprint(len(tu))
% I* O! ]/ J/ L+ F' h0 Qb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
* U. z2 D  e3 E0 \# G; i; Kfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- \, f) u" w9 R+ q3 c' h- g5 m- Mfor k,v in enumerate(tu,10) :
* E) q) y+ ?0 y    print(k,v)
10 alex
4 G7 q, `$ q: A6 ]3 g! z. |4 m- ^11 eric
12 rain

for k in enumerate(tu,10) :
" d6 W  x6 W5 j# ^: N4 v    print(k)
$ E7 D% i8 G# X) k( [) I2 I(10, 'alex')
(11, 'eric')
2 L% o) s; W9 L1 C; L  `; ?* e(12, 'rain')


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

元组，不可以

' }* x* d# D4 cd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% X+ l: g; h- [% B- Fres=tu[1][2]['k2'].append('seven')
* c3 [0 Q: s" l8 ]4 p5 @1 _  A
print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
$ w* L. b0 ~4 J! G* l+ x    print(i)b. 请循环输出所有的 value
4 J6 K( m8 x% mfor i in dic:
    print(dic)
: [  b3 }0 f/ B% b8 C- J. [c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
! I1 g6 M/ J3 A) V" @) Od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
7 t) O. L! Q$ H" qdic['k4']='v4'
print(dic)
' @  C( S4 ^* {, L+ ]4 I7 we. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# u4 u' \) y7 f$ K3 ?4 H5 e7 odic['k1']='alex'
& o+ C9 o) r( zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: E4 N; A' h) {8 d* ^dic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
4 T& ?: Y6 w3 p2 Lprint(dic)
3 }8 y# D* I" b2 ^27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 H0 z7 t: |2 p! }
# t( \) l: C6 k9 M# fprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))

9 O! {1 O! G( }' R2 Hb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)

5 i: ^" k$ Z0 G- k! G  z% Z/ K6 h
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. D, w; m8 n* e& @9 f: E6 t
dic={}
3 ~/ |; Z5 e, S/ Ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 y' \' @6 u7 k+ r: {5 x8 j; @( ]2 f! b  E    dic[k]=v
; z) x7 S, t% G! i    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. `1 ^  ~6 M( {a=n.encode('utf-8')   
. |. h% K* {. q/ Kprint(a)
- m* J. V  H9 L9 |% e$ mb=a.decode('utf-8')
3 n9 J: h. z( S8 ^: l" Fprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
# O2 h3 ^" O3 i. J# r- p- z8 c) Tprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
6 ]1 [7 Y5 l' p4 p5 m. rfor i in range(100) :
    sum=sum+count
0 `5 i# d0 ?+ L    count+=1
2 Q; V: {% _' B/ @4 |print(sum)

count=1
, c- e+ }6 f% H$ |+ }sum=0
) b, C0 ^3 a2 n4 V0 `4 x0 ~- d9 A+ Awhile count<=100 :
3 M9 O! _1 i+ L8 e4 b    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
8 b* z" C$ d" D, ]" s0 _将小于 66 的值保存至第二个 key 的值中。
- S1 }+ g  X+ Q* j4 J' G即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
( w, D0 Y/ {$ G0 t  T" Y    'min':[]
& T, I5 o' N2 E, J  x5 J}
5 i7 r6 \6 m: a* h. yfor i in li :
5 ^. w2 Z$ [4 C) j! ]* E. |3 _4 v* ?    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}