Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

7 f$ K1 I9 C9 v5 ?- o3、简述 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、如何查看变量在内存中的地址?
6 A' I  u8 `8 y/ n- m$ V* tz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

# I$ [7 _# H/ e9 K! l10、写代码
5 G' Y7 {& c9 L0 C& I1 Z# u4 L7 m5 ua.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
; ~1 y$ t$ \$ J$ |6 f' yname=input('name:').strip()
7 E6 c! v6 ^2 x6 H, Kpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
% g5 u( L/ i5 j    print('ok')
8 K1 T5 c0 r# i* }6 H# ?: B( I8 Gelse:
$ j) t: X- l' @* L    print('error')

' w6 K: B! \: s2 R* n0 E4 h5 D2 n% E1 ?b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
. b  R$ f' F# j" \& @2 j, C7 V    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
+ K4 f1 X5 D& O# Q' h$ N3 U        print('ok')
, I9 ^/ |/ e! U! p9 ], h4 C% b    else:
        print('error')
' E; w- F2 F, a8 D! S" M6 S* I. V        count += 1
for循环：
3 R! ^# y7 X# N# W2 nfor count in range(3) :
# h' L9 X4 c* T0 {! X" q    name = input('name:').strip()
9 x9 m; `$ G" u$ ?2 Y+ v9 Y    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
+ R1 s, I% n& v4 _3 s    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
) a/ H  [* Z6 B% b! Dwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
# O5 O( e! m- }    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
$ {7 k" i& k1 G# ]6 m2 e    else :
, t) x- m# g) X        print('error')
+ q, t$ V6 H3 Q        count+=1
9 k$ F3 m% y# C& D7 [3 Y8 ]  X6 ~for循环
for count in range(3)  :
    name = input('name: ')
! \! `+ c3 t. j0 {    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' T; T9 f: J2 N: c        print('ok')
4 K4 ?2 U: o- n    else :
, x$ |. K& g4 u$ g        print('error')
2 V, j0 \1 M4 N8 v: L. t        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
+ ]7 W- x  \2 I1 L, gcount=2
" j4 i' Z$ h+ e/ Fnum=0
+ z2 t% Y7 F! Y7 m% g* k6 Mwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
8 G; c8 D; M1 p6 |1 u    else:
        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
( t; t) w. N" ?2 ~' |6 \. qcount=1
for count in range(100) :
& \2 Q4 T" V, R: N% y7 x, |    if count % 2 == 0 :
        num=num - count
    else :
: |8 V4 J2 l5 C, N" q        num=num+count
print(num)

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

( g( ^  a; Z$ v" V0 ]1 \count=1
: ~: Y6 b; G5 b  I3 Q4 _0 V" n% f- Twhile count < 13 :
% |, i& {( S$ o5 {2 O    if count !=6 :
        if count !=10 :
            print(count)

  B+ @/ E4 S! I& H2 v  R# R    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
1 j( n6 h6 b$ x* C; J& {for i in range(101) :
. ?3 G# ?$ Z- E0 V0 D' w$ T    if i %2 != 0 :
4 s" r8 C+ A; l; H3 C% [7 }: `        print(i)
6 a7 j4 }! e7 Q4 G! I; a; t. {0 E$ ]
count=0
$ f4 ]$ u2 a, m% T# R+ v* wwhile count<100 :
- \; F7 D  ?; R    if count %2 != 0 :
9 E1 g& p* D+ U1 c0 }$ ]% ^+ t- }% M        print(count)
* R5 m7 W- x5 G    count += 1

+ z  r) I* H$ q+ w8 ae. 使用 while 循环实现输出 1-100 内的所有偶数
) f5 T4 _- t( z/ h0 o. u9 _/ ofor i in range(100) :
5 I1 p. D/ q1 g) @6 j. x) x    if i %2 == 0:
        print(i)
' L7 |" H8 ?. f5 T( o  x
count=0
while count<100 :
" s6 X# f' r/ m/ {& d, M1 i    if count%2 == 0 :
        print(count)
5 X: h) K- [+ I1 a9 S    count+=1
" y6 [0 a" o  u$ [
- Q' b! V! h( R; [) [12、分别书写数字 5，10，32，7 的二进制表示

. R- h1 \' d! ]print(bin(5))二进制   0b101
! a: S/ N$ d( }! o8 @8 K3 d# \print(hex(10))十六进制  0x5
9 c8 T& v* D2 B+ D& m! _  eprint(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

, w* d8 b: {, J20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
- L) Q2 V4 J& M6 I9 L2 G1 ba. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
7 j) Q8 d( j8 Pc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
  ?# V! ~$ d: V4 |. Y" mprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

( |  U# i% F' ^j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
. h% h" ]: W" V! M$ D1 x0 Y8 N21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
( B2 C0 \6 q3 M2 Z: |+ B: B! O依赖索引
/ Y. }2 J7 ?/ z7 Z  ]0 Fname = "Alex  "
+ k' k/ y7 i7 U' @for i in range(len(name)) :
+ |- U5 @* C( n, M6 e; \    print(name)
for i in name:
# `$ j4 a) b. Y' A; ]$ t    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
5 v$ \% M8 i0 K: v" e! Sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
+ u3 W$ M/ V$ cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
( h* O1 U. z* Vli.pop(1)
" _. P7 r$ v# C& r; u) Rprint(li)    ['alex', 'rain']
6 j, t& l8 ?, @4 L& v! @5 Y4 ?指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
) Y8 x, v( ]7 D+ ]% l* k4 F/ Rprint(li)
/ f% M) [$ R# h: @  O7 R1 D& ?
$ M) H0 x' C4 V- R, X! c; `" i* i' Xeric
/ l" s. G! x6 E7 g+ o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
( [# h. [  k  k% p7 g8 ]del li[1:]
/ {( O6 U9 D* }: q- N! Nprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 S) a+ ]" {: r. T# e6 }/ Xli = ['alex', 'eric', 'rain']
9 \% X% H& R  E7 jfor k,v in enumerate(li,1):
' ^6 R1 L' Z, c/ O+ x0 W: P    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
' z7 E! x0 ~" q9 x$ v$ Gb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
- w/ Y1 w7 D' C6 Eprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
! U: L, B; W7 T7 L- w0 zb. 获取元组的第 2 个元素，并输出
* I+ M7 u0 K& {3 h5 Bprint(tu[1])
' G$ r9 f) k( ^5 \, u$ R, q- Ie. 请使用 for、len、range 输出元组的索引
; g9 Q; w+ o/ e$ `" n) d) _for i in range(len(tu)) :
  v' r& i" I; K. {    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: G* u1 h: {9 Yfor k,v in enumerate(tu,10) :
  S4 s2 V; }6 q; G    print(k,v)
& U& l! h* Q/ |. [5 R( z4 L% e. N10 alex
11 eric
12 rain

' p3 s  m" _: E% cfor k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')
% j6 ?4 _+ L$ A

$ R. C7 p/ ~" B8 S1 a$ N6 H7 u7 L( t& O25、有如下变量，请实现要求的功能
6 I+ _3 h0 b+ Q9 q  {# ~7 Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
' ^' T0 O$ a7 A7 K' I5 g0 `" etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

6 {3 P9 U' W1 r* f3 N, h8 Y' t$ ~print(tu)
( S' T/ A, g* o. `$ i, n5 f" x) E26、字典
. \. J- l& I* v8 Ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
/ f/ X0 E) Q7 d# b% t    print(i)b. 请循环输出所有的 value
: s* L& B9 I" t( o" V8 Z% Tfor i in dic:
    print(dic)
4 z* Z& O* t# q4 S2 k! [c. 请循环输出所有的 key 和 valuefor i in dic:
/ J2 i3 @+ g  Pprint(i,dic)
3 |& T! t+ J8 I$ [% vd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
% ]1 @7 B: D# h4 Sprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
; M  R4 L9 |) [0 Z% s$ X( [dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

& j# Q) d0 j7 r3 O% Hg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
  R( Y; [  K3 ^2 Z( e$ Ddic['k3'].insert(0,44)
% b( c& u& u$ G) nprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
* C( p- U4 X5 R3 J$ v. t3 ~" i0 E
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 R9 F" q, q! t" Q4 ~2 Hs = "alex"
print(tuple(s))
9 \% [7 T. o# f) F: a) k
6 f9 D: E+ k* x1 {2 [% Q/ Q# ~b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
* b6 k8 o4 X8 h# U1 q" R7 N- ^print(li)
* H& Y" L+ K5 |) ~& e

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
1 z0 @; Z1 [* A9 t' b& k0 M
2 @2 F. A5 }$ B& l; m' x- udic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
$ y7 Z* D8 X4 y# G; Mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% q0 C+ B2 n- |7 P  b/ t: I4 t1 oprint(a)
1 C: R" j0 v& t7 Pb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
6 N2 I/ k7 Y5 k: efor i in range(100) :
. @$ Z. d4 Z4 T8 B' d! t' o    sum=sum+count
2 m8 j9 W! l/ A* c6 D    count+=1
' N$ b7 q/ Y% ?( {: Cprint(sum)

count=1
sum=0
while count<=100 :
. W) M  @/ T' c5 g; p- ^    sum+=count
7 i) d$ h) Y, t8 P. a9 v) ]  W$ O    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
% j; K* n) [% F% E: ]+ Gli=[11,22,33,44,55,66,77,88,99,90]
) D( I2 m6 B$ [7 Zdic1={
% |8 Y, _  j6 z8 D% s: T8 l    'max':[],
    'min':[]
, h7 `2 Q+ F7 U, \0 @' G}
3 s+ B$ j# {2 ?; Ffor i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
+ M3 n+ y! Z/ g% W0 U1 c        dic1['max'].append(i)
0 A* c) ?  }3 U* i$ R' {  G" P+ Sprint(dic1)
0 ]; w7 ]4 H3 G: f
5 {7 a8 z) e% f7 ~* H---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}