Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

- M0 s& m& A2 c5 C) g- Q5 c( W, R. Y3、简述 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的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
1 l1 s( F6 l/ ~! ?7 E, K+ ^z=1
, `" f) y1 S2 K5 y3 a; g; n$ z4 x  X% Wprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
+ E: U; T9 g) I* a5 B& hpwd=input('pwd：').strip()
- B! x- E! `4 y. z( nif name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
2 z7 q" v6 r: acount=1
6 S* [2 [! O+ `. B" a* E+ Iwhile count<=3 :
    name = input('name:').strip()
* o6 ~4 {7 b, C! R1 z9 v$ ^    pwd = input('pwd：').strip()
  |9 J6 R7 V) l
- F2 f- z- ]5 s    if name=='seven' and pwd=='123' :
8 c. P" Y# x! z2 v! m* `        print('ok')
    else:
        print('error')
* |0 |5 `% q4 F3 Y  A0 c        count += 1
! @; h+ c) p0 d# \8 Z, @( ]/ |for循环：
for count in range(3) :
6 E4 O: F5 h6 M' O; w8 A    name = input('name:').strip()
  h" s3 I( d4 n    pwd = input('pwd：').strip()
/ J# [4 X! a+ c; E! g
8 L, F+ @7 z+ \" _/ o' u    if name=='seven' and pwd=='123' :
        print('ok')
    else:
- a- X! w1 j7 h; ~  v4 c7 P* C        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
3 Q6 D/ c1 |9 Fcount =1
) ~% w( S( t( {while count<=3 :
    name = input('name: ')
6 R& M& ^% Y  ^, i    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 z! W  ?4 G9 v2 O" Q0 v* N        print('ok')
8 [0 I; g, [4 q3 A' b9 j    else :
& m- y$ h, O# x1 R+ c' `        print('error')
        count+=1
& b# j/ ^) P. n! {for循环
for count in range(3)  :
# `. W! i) V4 e9 ]: t    name = input('name: ')
7 l' A4 W' T5 L' q. K' }    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; o/ E- k& e. Y9 h- ]        print('ok')
3 I5 d/ {, s0 t3 f5 C    else :
        print('error')
        count+=111、写代码
' }& ?, R: J: `, Q) g2 ~4 M0 _a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
1 H1 ?/ O1 N) B$ S( gwhile count<=100 :
    if count % 2 ==0 :
) x: g- |2 \! j3 {8 T        num=count+num
        count+=1
    else:
& p. \" \3 h: y        num=num-count
* Y) S  p# F8 N$ h, G' o$ w        count+=1
. k; O; h) I5 o' V9 kprint(num)
1 G; Q) f. b- o1 I+ ~
/ Z# u3 R; w# G% y6 [" W  J. y: E9 Bb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
2 A5 F: N/ g: ]8 d num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
* o; B' j: j3 ?9 c0 Q# J2 x  _        num=num - count
& \4 ^; z0 o$ }. |5 j# o2 [    else :
- i* [% ?- S7 A# c7 W  |        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 :
3 ?" y" l6 u) o" S* {& T% j6 s) }        if count !=10 :
+ Y: [9 v  B, N            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
/ ?1 C$ Z0 W$ N. h, u* h! A        print(i)

" R5 a. i) p$ P$ H+ a: Scount=0
* o- V  K' {3 A. ~( d) l$ i/ gwhile count<100 :
: ~" M- u* C( o+ y8 _    if count %2 != 0 :
8 s; W) C& @; F9 O$ f7 u0 j1 _        print(count)
    count += 1
, v* @4 S& K* l; n
e. 使用 while 循环实现输出 1-100 内的所有偶数
% S& E7 Y8 C. z& [3 qfor i in range(100) :
    if i %2 == 0:
) I+ K) Y3 `, s, ?" L        print(i)

5 r& {' s: m8 C4 ecount=0
while count<100 :
    if count%2 == 0 :
: E8 c1 B- l1 ]+ z# d. o* H        print(count)
    count+=1
. X) R4 P# J  r2 r
$ V% f% Y$ @* M9 j4 X3 k2 X9 c5 @# D- k12、分别书写数字 5，10，32，7 的二进制表示
4 L- I4 d5 `3 q' v; j% ^
) E2 }0 _& x, V  {0 X2 Rprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
; l2 m0 A0 B2 `; ?4 X, ^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

3 k' V& }0 p" e( A18、布尔值分别有什么?

False .Ture ,或1  和0

- c0 I5 W% U+ `9 ~( ]8 d20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
' `" |5 u' x2 @% p- W) D! v2 h) Ea. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
  w9 _! e; E" C3 g- I
4 r, W8 p5 a' l* M3 zb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
7 w) \2 T0 L. v" qprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
) F; F' F3 H6 Q8 Sd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
" @( f& l* D, G- n  L" d, {9 Zprint(name.replace('l','p'))   apex  
7 C- j" ~5 d/ k. Ie. 将 name 变量对应的值根据 “l” 分割，并输出结果。
5 _0 T. P6 D8 K& Qprint(name.split('e'))   ['al', 'x  ']  列表
0 ?0 Z/ N7 C! K9 s# r3 m% K7 ~
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

6 P4 x" j4 a# Y8 L3 Q, E; m; Pj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
; n. S3 w& @, w) M1 ~依赖索引
# A, R* I: f! M) U/ \! |( iname = "Alex  "
" m' z0 ~6 @* B) O! J! `, T- C) gfor i in range(len(name)) :
  ~; G) y- `; U1 c: b$ y7 k    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
2 }0 b0 k9 ~+ `+ }# s22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, L+ E, x# N8 p* H. M7 l- Bprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
/ S: ~: ?3 G7 I1 sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% j4 u! B* N) _. j. Gprint(li)
9 `1 h/ ^% u  w3 D& M4 {  X7 se. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
4 z( s2 ?4 v0 X6 ~8 t/ h( kprint(li)    ['alex', 'rain']
6 M: d5 N( `) z0 t" I( |1 A指名道姓的删除li = ['alex', 'eric', 'rain']
; [0 B- d1 N. w6 a$ _' ]1 Vli.remove('alex')
print(li)
: o7 k* T/ X2 b* Q' G; F) kf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
/ {  N  H# G) E" j. F# f+ Bprint(li)

4 h% t4 U6 Q( M' o7 Zeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) \4 C7 v3 c; T2 |% D' }del li[1:]
2 D6 J8 {: I; B2 R: v( y4 J5 Oprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
: t- `* R* E' U4 j% z/ j+ Rfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
! A+ D. X# w3 `5 ?: \li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; l  p5 e$ \: o; I6 }print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
4 u+ a4 O" N# T5 T24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
1 Q2 b: o2 E! E: {( ?print(tu[1])
e. 请使用 for、len、range 输出元组的索引
+ U8 j" R: G1 Hfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
2 l5 y/ n& b4 M4 |( s10 alex
: E7 X; r5 ~  n( A6 `11 eric
12 rain

  |7 ~# M  v5 [/ |1 n- Q/ Xfor k in enumerate(tu,10) :
    print(k)
% F6 K$ e2 v8 G' Q(10, 'alex')
  Q( h4 e# `; y5 j. @(11, 'eric')
# M+ s, W% ]0 \8 {) H* }(12, 'rain')
/ Y8 p' {, x; t) p5 r# P1 `+ E
7 F4 K6 ]0 b) f: x
25、有如下变量，请实现要求的功能
! c' E+ P  l. q1 atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
$ E+ m2 M! g. L6 `1 a5 N. C
print(tu)
6 O, P' K- X6 l" K26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( t2 V5 x' g  M/ s    print(i)b. 请循环输出所有的 value
for i in dic:
+ d) w8 `  d6 O! ?* k+ v1 k! d+ b    print(dic)
8 n. U9 C( R* ^5 v" v0 uc. 请循环输出所有的 key 和 valuefor i in dic:
8 T- h5 w/ Y/ Eprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
: Y5 M' `3 U: D/ x9 l( J5 @& D  @e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: u: M9 D! w/ g! Z! tdic['k3'].append(44)
print(dic)

, A$ u% ^# E8 b0 m. I; bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- A. M+ L- P, }* Y# Bdic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
# w* P& I& m; g0 u2 F7 r' }s = "alex"
8 Q7 j0 c5 u' b( o; P3 H9 Nprint(tuple(s))
# `4 Y8 j' K, }2 Q  C) E& G/ z, B
b. 将列表 li = ["alex", "seven"] 转换成元组
5 m/ j  y! n4 T6 x' s- C0 }5 M) m4 nli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 I1 w1 H: z" W3 K* q5 c" `; J+ H# e% Ttu = ('Alex', "seven")
li=list(tu)
8 V! B# |, @4 x' l: c: J! Z/ Lprint(li)


, `* D- j/ Z  e& y& Dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
0 k$ \* z$ U& gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
( s! p1 j" V# u1 S+ q    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
2 u9 p' P' H; ta=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
6 l- h, _$ e# a' T1 {print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% A& y; P( l" J# d# S& xprint(a)
b=a.decode('gbk')
" r( U# X# @, n: Iprint(b)28、求 1-100 内的所有数的和
count=1
, i/ d6 ^7 q( [( M9 g" V: Isum=0
for i in range(100) :
6 m* z) I& \$ s: s8 Z    sum=sum+count
7 {- H* R: h* V    count+=1
print(sum)

count=1
+ L- y6 Y4 O, ]" q& \, Y1 E, `# esum=0
4 y; _; Q; l& ?( `$ X" kwhile count<=100 :
( I* q. Z3 N, p7 i" ~    sum+=count
    count+=1
1 z2 u: Z1 P$ g4 [; d% uprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
& r" {. G% V$ h  ^; n4 t3 X0 @即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
1 \2 O% }3 z' m4 pli=[11,22,33,44,55,66,77,88,99,90]
dic1={
) }. r/ I4 _8 n: K7 n    'max':[],
/ |# P) Q: h+ [1 N# V    'min':[]
}
for i in li :
    if i <66 :
- c* B0 S' l' M/ }. X* t! n        dic1['min'].append(i)
8 l/ r, e$ F4 y  s, I$ }' {5 E    else:
% b0 W7 C' L* n$ b) P        dic1['max'].append(i)
print(dic1)

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