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

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

* p/ Y* s% a9 a1 L/ R/ D5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

( o4 b/ Y' ^/ J8 q8、如何查看变量在内存中的地址?
z=1
% O; L2 `0 I9 x2 t4 Kprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
- u* j3 r; ?: E$ R  cpwd=input('pwd：').strip()
$ @. H1 a- Z) A: X! eif name=='seven' and pwd=='123' :
! y; }& ?! ~- ^- s6 c/ U  _    print('ok')
else:
    print('error')
7 y$ L# {4 r& G3 P3 A
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
  y$ m$ H5 u, {7 w& Wwhile count<=3 :
    name = input('name:').strip()
6 c: p' {- L' I: x6 X2 h$ n) F    pwd = input('pwd：').strip()
  q5 ~( V0 M2 h3 O$ T; |$ }2 u+ k& W
    if name=='seven' and pwd=='123' :
$ f' T5 k" L; x3 f/ r7 A% g6 {6 Y        print('ok')
$ [. Y- p9 C- T) n: W    else:
        print('error')
        count += 1
for循环：
2 c0 d) }1 T8 m5 Pfor count in range(3) :
2 u; L& W3 ^# }3 Q5 C5 w. o( p    name = input('name:').strip()
    pwd = input('pwd：').strip()
3 N% O/ s( i( W* B; [
7 S, K. Y: X& H7 [# Z! k  ~  f1 [7 G    if name=='seven' and pwd=='123' :
2 O: l. w! l' j! ^" p, P: Q- I        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
( Q$ x# o# a& ?) E/ C4 Twhile count<=3 :
) F& B  N( \2 P& k, a" I' `    name = input('name: ')
    pwd = input('pwd: ')
1 }- ?# A6 A  f: Z8 J/ d    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
$ }5 i* `" e! s7 p        print('ok')
  P9 L& K/ N6 |$ f3 o    else :
3 |  W) T: v+ N0 U2 A        print('error')
. @& T- c$ f5 W, M: j1 h        count+=1
for循环
for count in range(3)  :
! F) Q8 D$ ?& s0 E    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
  i1 z6 E, Y, x5 s: T- w6 f1 r1 U    else :
1 a+ P. y+ a* _% \$ r) Y; t! f0 H  J' |        print('error')
5 l! J% J! Q5 d/ z1 B  R, Q+ {        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
) V0 `; i: n7 a5 ^. W4 p5 Z% p: Ecount=2
num=0
* r( l( v: I2 \2 e- S7 _while count<=100 :
    if count % 2 ==0 :
8 O! v$ A% o+ C3 |9 A; |        num=count+num
+ z. f  w8 c5 H' T: y2 ?. R$ z- |        count+=1
    else:
        num=num-count
        count+=1
+ R9 y% Q  p4 x! Bprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
7 `/ @; @- r8 I2 p num=0
count=1
# W; m% n- C- ?+ y$ o) ufor count in range(100) :
) v$ }1 I# O( j3 z" h5 C    if count % 2 == 0 :
1 _% R& z. M# V# M4 O! j, P        num=num - count
5 W$ J( ]1 g7 ^7 a, B! ^) O    else :
# V( ]( v4 ?( S  j5 t        num=num+count
- z0 s& c1 @% h1 Rprint(num)

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

count=1
while count < 13 :
2 a7 W5 B3 _  I# g- o    if count !=6 :
, e+ i+ x8 n- O- p        if count !=10 :
- A3 ?# m- V( Q3 ^% h: R% r            print(count)
6 K  f: x+ p. B, [. d/ r5 T
( f2 H2 _5 B; b) i    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
" S5 t- A8 M7 V# ofor i in range(101) :
    if i %2 != 0 :
) i# |7 i- c3 U% H8 Z        print(i)

count=0
( G" Z* H- t4 N+ q* Uwhile count<100 :
7 ^1 U3 b: F& X! y$ d, v* l    if count %2 != 0 :
        print(count)
    count += 1
1 v0 K+ O+ {! }
. A7 I; R; S5 U3 s* oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
9 ~+ K7 I/ O  W, U* r) l) C2 [    if i %2 == 0:
        print(i)
, m) i! f) Z9 f2 `- G9 E
& W* k  q" r8 I5 @, i) ?count=0
while count<100 :
! |. C% j+ j; B9 {& U    if count%2 == 0 :
        print(count)
+ @3 a9 y" Y% x5 d* o    count+=1
, ]3 E7 r; E1 k. B1 @3 M7 Y
12、分别书写数字 5，10，32，7 的二进制表示
1 H4 F! ]5 I2 V0 b" t5 O
7 X4 i7 p3 ?/ n4 T2 j/ N, ?7 ^) s3 |print(bin(5))二进制   0b101
/ C' O* T8 {/ k- X2 Uprint(hex(10))十六进制  0x5
$ T7 e( ?/ ^* S  q" W7 y5 ~& Q5 Iprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

+ \! J# w8 E: \: h16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
  Y: O* g: U! S; b( a" h17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
- @2 ~: F1 I6 ]print(int.bit_length(n1))  结果  3

! q# O" Q% k6 K3 U+ _: ~' Q
18、布尔值分别有什么?

False .Ture ,或1  和0

2 s; }! T' w8 V7 \$ I" r' y5 Z" w20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

2 ^! S( V" S6 w( G, P8 }( Wb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
- P0 W: L" U3 K! Kprint(name.startswith('al'))
9 `; \; X4 I" oc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
0 d. d8 ^8 U+ `, J# T) h" {
; s- W* G5 r* V3 I/ {/ }' p* Xg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

$ M/ o6 z" M2 l+ E( s6 ~* j0 ^1 Ej. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
( i" v# m* a3 u3 m8 P5 C$ P21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
# r+ f% F7 a( x- nname = "Alex  "
for i in range(len(name)) :
4 P5 B3 ]" e( P* m7 H# Y2 i    print(name)
6 t" }5 f$ r: B7 K" y2 n# }for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
' @" y) j# S9 a" m+ U22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
/ Y7 _" l! a5 m/ k. sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
8 G, S: h7 ~( a# k2 j4 M) i. |, ~print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, J$ @7 A% M  U9 a; h: w1 Z, Jprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
  ^) k5 ~# |+ S% S3 ~5 t( S/ F0 tprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
/ l8 V9 l5 Q+ S3 Gprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
; O- r, F5 q7 \# S/ F# u4 O8 A# V. jprint(li)

3 q6 n) `# }* q- j3 H8 ^eric
* m2 h  ]5 y  U3 w0 [4 x['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
6 ]/ Z0 k8 a5 `& h6 ?$ E/ o+ Odel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
" m: v3 A* \3 x. ]( tli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
3 z2 r: N. [& H* V5 S+ Q. ^. N24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
7 g0 J: y' i9 q! y  d( x: la. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
! ]( y* V$ ~. W/ A& zprint(len(tu))
1 U- o# o( ]# S( \b. 获取元组的第 2 个元素，并输出
1 j! i/ H. G. ?1 j! H9 D; Dprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
' D* ?; \* R6 M& m$ L    print(k,v)
10 alex
: D% p. o! }" C! W( ~/ k* c) `11 eric
0 C: {! O* y2 Z$ T  d12 rain
! L# I9 y7 v) N& N" P- n
for k in enumerate(tu,10) :
* c/ {2 L; v5 P; U+ @$ E1 y    print(k)
(10, 'alex')
4 Z$ ?% J* M+ I9 P4 n1 @6 R' Y(11, 'eric')
4 Q* d: e7 D: }  C8 V(12, 'rain')
4 x8 q; ~% U3 W: V- c! M
5 e8 f1 I; U+ d
6 p" O, z& u' z8 c# f5 z2 ~- c25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

& d/ _2 m$ U2 Vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
: v# Y$ |$ Y3 ores=tu[1][2]['k2'].append('seven')
, G' }$ M; q4 c9 S' z
( Y$ i- G* R' |, y5 u, I3 ~print(tu)
5 Z. ~5 R5 `# Y7 g26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
5 f' @9 S3 Y: j  c6 y    print(i)b. 请循环输出所有的 value
( b9 Y- ~3 q* K9 rfor i in dic:
9 L: Z+ g; {/ B" ^  T# |    print(dic)
) m# @* r, |9 }5 A0 W& ^c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
0 b5 j) k0 g, U. X8 xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
: z  N$ G' x* n( c$ \- \3 lprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' ~  {, T' E  S/ f7 T7 ]# C; g3 v+ |dic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
' e# K; n* u) B) nprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
; ]3 k- o8 r( d" I5 Z( K- ]print(tuple(s))
* E% I+ H" [6 }9 A  T3 ]6 ?+ W
. ~3 }6 o$ S& V- O+ Db. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
) G+ m  l2 l$ P% S( W) h/ A) wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
8 ~% [, `& \* ~print(li)


& v% [) b* E- X; y4 ud. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

  _1 v) g9 u) V5 ?  Odic={}
9 I5 ^, O# w" o7 f3 n9 F$ Hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
( `8 g( _( {# o' ]) ~! q    dic[k]=v
3 C) @* a- y2 t0 K$ y    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
4 i+ V$ ~/ @' D0 b6 e( c" Kprint(a)
b=a.decode('utf-8')
, T0 P  r) L$ V$ e& K" yprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
, Q6 E; P0 m! C& Ab=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
$ j# r% V- a5 B. gcount=1
sum=0
0 Y9 i9 y7 ?1 f; Z1 X) sfor i in range(100) :
    sum=sum+count
    count+=1
print(sum)

& [8 J0 o) t  v, fcount=1
sum=0
5 b" H5 f1 H/ Gwhile count<=100 :
    sum+=count
0 d- T" W3 L) }: z9 ]    count+=1
. d# k" o0 x( {& \8 T' X7 f9 C8 a$ oprint(sum)29、元素分类
$ C( l; g: `& J! V- U9 {3 p有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ C. Z/ S3 |3 l" [将小于 66 的值保存至第二个 key 的值中。
, \+ ~; o2 ]- ?# g# \1 D; J即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
0 |7 @/ R0 ^1 g4 {}
- ?4 d0 V. Y8 afor i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
" L  {+ v2 k' O# H9 [! l7 \( V
* u7 `0 D' l9 s* V/ V---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
' \  Y$ R- p9 B6 ^& a