Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

: I) z" q! o' C3 }$ E3、简述 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 K, _* q& O% ^; u4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

4 s) F  H9 s) m$ p6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
' e5 B# ]1 g8 ~6 C# @1 z3 ]  @a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
; U) [$ t! r% p, [( Q  p# k6 }name=input('name:').strip()
: H8 l+ M4 J0 ]2 y( m. `- }8 ipwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
2 g8 R' ]% E8 R1 n$ @- ?7 d    print('ok')
8 S) o; @8 S* U# W  Y2 B( \else:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
  E  ^& R% }. C: v' N' Ewhile count<=3 :
5 Q8 J/ Z5 J  A    name = input('name:').strip()
% N' M$ n+ |8 @: L8 j+ E% A  i- d    pwd = input('pwd：').strip()
; \2 i# F# r8 o* s/ b3 u
! C1 v! T. y" [6 _    if name=='seven' and pwd=='123' :
        print('ok')
% r- j0 k, i/ D& m8 I    else:
3 B1 H& ]! K/ e3 w6 C6 s        print('error')
3 @- ], D/ P" H  p/ \        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
8 B# s% A' J3 W7 F0 D) Q# x$ @
    if name=='seven' and pwd=='123' :
        print('ok')
$ C" y2 ^* V, ]6 P0 r4 S    else:
$ n: p7 q8 z: W        print('error')
- m4 h$ j7 B' {- P2 F        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
  ?/ r8 l" W% i9 U0 Gwhile count<=3 :
    name = input('name: ')
5 ?6 o) W' m) a    pwd = input('pwd: ')
) c; p2 g) C3 V" `5 \    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 K; R: `, i' ^1 E7 o$ M2 ~        print('ok')
    else :
        print('error')
& W7 d5 @/ ^: J! I8 D) `        count+=1
6 V- U. E3 s3 w- Lfor循环
for count in range(3)  :
    name = input('name: ')
7 A& ^* U& ^0 w3 G+ r/ i2 t    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
7 m1 d  i7 C/ M3 W, U( \1 M    else :
6 {. c8 }2 E6 B& I# ~' K& Q        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
! @7 `. C+ G$ `: ~count=2
num=0
& J8 W2 H7 g8 Z* `while count<=100 :
2 d( Z0 ?# L8 }- R& c    if count % 2 ==0 :
        num=count+num
! H0 [. A/ n3 C( z$ o/ V. K        count+=1
    else:
" Q* h2 l" Q. p8 m' o: V        num=num-count
* s8 G$ \, a0 I" Z/ y0 R9 Y) }        count+=1
print(num)

, [$ Z- [2 K1 ~2 v8 X( cb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
5 J) i. K6 \$ u$ o( Kfor count in range(100) :
$ V3 {+ O7 i2 M! I    if count % 2 == 0 :
' o3 C3 _3 S3 E1 z        num=num - count
* D. I3 J# e9 `: ?6 p& v- ]- s3 Z/ c    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 :
        if count !=10 :
            print(count)
$ S- l4 C' K& d( G
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
: m/ e& d% }( m' V" s) k: I* Pfor i in range(101) :
    if i %2 != 0 :
; \( h4 O. j) d, p        print(i)

1 l% E; Z, P7 C7 {! Y, \2 r. xcount=0
while count<100 :
7 P9 U' W' `& C    if count %2 != 0 :
        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
) `( V" g% r; B4 [" e    if i %2 == 0:
        print(i)

& i" ]% ?, q* T2 X8 ~5 B- fcount=0
while count<100 :
$ e) q9 e( u' z    if count%2 == 0 :
% u% T& M9 U0 f6 f        print(count)
: E! S. x! {  n+ ?+ U; e! y3 q    count+=1

. y& D6 n# o: H2 h2 I% f8 Z8 }12、分别书写数字 5，10，32，7 的二进制表示
$ w3 J' f" H' ]! ]9 B
( _" C/ o! G3 Z5 j5 [print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
' A1 p3 z- C9 a7 C2 Z8 P14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

3 I& l: C) Q3 l. @" [- D# E9 X16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
" z3 X: Q# m4 k7 Q. h2 r( oprint(int.bit_length(n1))  结果  3

; m5 k  g0 k8 B2 F' o
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
: R! @6 d7 `9 o/ ]+ ?: r
1 _& E' t3 w) H- ?3 P+ t  Mb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
" S. W- n% q1 r, j) yprint(name.startswith('al'))
; i0 K" J4 ^+ v6 g7 J+ Ec. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
" i2 ?& ~; j& v8 F; T% G% _6 U, gd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

. L, b1 ~) ?* N" i9 |( Ig. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

* K9 q5 Q3 C8 ~' ]j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
2 q) ~/ y- c  ^4 o! m% r, ?21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
% V3 M+ R, C1 X依赖索引
7 i: S2 O) h& p5 W  \' iname = "Alex  "
for i in range(len(name)) :
    print(name)
  t- R  b! Q4 u' z8 Hfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
# F7 b; [+ n5 g6 ~' R' p" A4 Z- @22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
# C' ~& n, J! n" [; n8 @print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
+ \+ |2 l, \; {2 Yc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 B1 w- P! h& e) bprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 D, v" S# D3 Y* n6 f+ I7 _print(li)
( B" _, R$ t/ De. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
4 E. A5 D! ?$ N1 K  ~7 w& @print(li)    ['alex', 'rain']
; V: X2 T2 K1 T1 M0 Q9 G指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
- f. z3 a# w/ z+ l5 X! }" h$ yf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
! O2 I2 X' l# k7 W9 C+ L' s$ V4 hprint(li)
# u" d& |' W% b# F
eric
( O' k' A. L' ?3 I1 R* v['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, v& C2 _# z+ D3 T( Q+ ^( Idel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
" s# w+ J+ K0 ?4 a    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 @0 p# o5 X+ L' F, g) Ma. 请输出 “Kelly”
" ^: f) {5 U( }! R- Ili = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) V1 f& l" r6 q2 Tprint(li[2][1][1])
" @7 t! h7 M+ ?2 tb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
8 u' A6 ]5 a1 O( u% h/ l9 d- afor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
! e' K$ u$ K8 r" D: L    print(k,v)
0 D; @6 p) p8 U10 alex
- T$ K; n( @7 n& ^$ ?11 eric
12 rain

. q& z& P0 l. D! ]6 Q: yfor k in enumerate(tu,10) :
    print(k)
+ t2 O$ E. C7 k' c! I% Y2 S(10, 'alex')
(11, 'eric')
(12, 'rain')


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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
3 v. o) r' G' ?2 X: N4 n+ Utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
+ T0 Y1 H; I# w7 L
print(tu)
3 w0 q1 S. ?: d2 a1 y' E7 j0 F26、字典
4 p5 U& p! ?/ t9 T! h& @  Vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
7 m' O% m# m& m3 c& u5 s( w, m    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
: E, o& S& d* c: Fprint(i,dic)
+ T* B# a( v  F' N) e7 Zd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
* P2 R# ~, E# x& {dic['k1']='alex'
# P5 g% P% t) g  O( r, [( ?print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' v/ H( X1 T) T  j% Edic['k3'].append(44)
print(dic)

! z: B4 x6 |9 K! M2 T% Fg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 {# s$ @( p4 y# x+ p& [9 {) E0 ^dic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
1 l. J: h$ f! Y8 G! Yprint(tuple(s))
/ r* M( H4 t! }2 d: v1 m
b. 将列表 li = ["alex", "seven"] 转换成元组
* S3 i( Q! k- ]: O: w$ @. `li = ["alex", "seven"]
+ H6 |/ p0 }. l2 Qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)


& w  Z5 x" F) ?! u, A9 Td. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
7 J, T8 l7 |  H1 ~) E( Z* E
$ l# U' T" m7 Q9 W3 h, O) p! Cdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
! a5 }9 u$ i* x( [. [a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ W; ]& @+ K& ?+ |: P2 a! n' a8 _a=n.encode('utf-8')   
0 o+ O& [: P0 x* D. qprint(a)
b=a.decode('utf-8')
8 a3 H. L% C2 m* C2 xprint(b)
9 \2 O; p* M4 ^b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) d1 u$ a' R; i; _$ Nprint(a)
  P0 |) C' Y" ?: Gb=a.decode('gbk')
1 x+ i2 R: Y7 I* {3 L- `) Q' {. K" Oprint(b)28、求 1-100 内的所有数的和
: w( s" ?3 K# i. X& zcount=1
sum=0
for i in range(100) :
9 @) X) g/ B$ |: B( U    sum=sum+count
    count+=1
. O% W/ d$ h5 D) i/ uprint(sum)
; j9 F# }2 O& L5 ~. U" m3 _
$ Y( H/ Y0 k8 w* N0 N0 N' j$ Vcount=1
7 I  P5 U0 R) gsum=0
' Q. _. n( D" G# X' x/ H1 N- w! Fwhile count<=100 :
1 ?' D# l0 o$ \* I7 y! k    sum+=count
    count+=1
print(sum)29、元素分类
- A9 s( X( a7 U: F% ^有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. V4 I# T1 }4 H' v+ \1 U/ X) R将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
, Y5 V1 A7 j3 K8 ?7 ?dic1={
. F8 x9 s7 v; A3 S    'max':[],
: u6 C4 A6 L+ _    'min':[]
0 S' Q! w, `. E. K4 g9 F}
for i in li :
+ E5 C$ ~( U" L* H7 p% e  h    if i <66 :
5 N: N) g) _* p1 W2 ~1 {0 V  ~        dic1['min'].append(i)
* `- i  Q& ~+ E    else:
* X: Z$ A7 \# z5 K. u9 T        dic1['max'].append(i)
" Y) T/ C  k5 I) e- iprint(dic1)

+ j- `* }* i3 w) {- _5 }/ {---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}