Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

  q& G0 M, p% N8 z6 W7 i" \; c3 s+ Q3、简述 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 v/ I+ W! i- \0 W+ y. B4 y5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

! Q3 a/ {) r! O) k; V4 z: _8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
5 g/ p" D& w5 k* W$ kname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')

& E+ J! w! ]( K4 `( Zb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
, L* Y7 N1 ^4 O( D  Vcount=1
while count<=3 :
) K! F# d: b7 w7 v2 }    name = input('name:').strip()
+ i1 D% z' x( H3 A! f2 |    pwd = input('pwd：').strip()
6 R: u* w  z' A3 q9 q9 F8 y. X5 D
& v; g) N; n) r; D# h    if name=='seven' and pwd=='123' :
8 Q) D' i* q. l        print('ok')
& A+ ?4 Z* ^4 }    else:
        print('error')
        count += 1
; z" U6 Y8 P' G5 n4 i/ y( H! tfor循环：
- l1 Y: w% h' ]/ z/ efor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

/ V# F5 e4 G5 J9 v$ ?. w    if name=='seven' and pwd=='123' :
" ~& Q( c- D6 @* e/ a6 g6 Q        print('ok')
7 @; }/ A* G! L9 E& ^    else:
: n, ^" f( V6 Z5 T- ]3 V# K9 v4 G        print('error')
8 f1 X; y' r, o2 t        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
# N! d7 @& n% \5 O( m. Scount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 E  E, d& }5 q8 A& r; l4 H        print('ok')
6 y3 K1 r! }8 e! R    else :
$ ~* ]1 j' r4 F% C" m& s% v        print('error')
4 A. G+ k) ]% z/ \0 h        count+=1
% Z, X4 d6 h7 R0 s" Gfor循环
  z9 P! |5 D$ J! g( W: ifor count in range(3)  :
; M9 n. l# Z1 L: z% L% D: t/ m    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
' ^2 C' ], ^4 F9 W" C* n: E0 F    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
- X/ |& s" C# Ccount=2
num=0
0 {7 g8 {% {) X# }while count<=100 :
    if count % 2 ==0 :
        num=count+num
/ D4 t3 T3 z5 O: u        count+=1
    else:
% s  L2 D; b) Q& F; ~- f/ q        num=num-count
        count+=1
" P4 s( o* p3 y7 |3 f7 A4 nprint(num)
% f4 O$ p! i4 c, M
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
" D# c7 k  J& b% {  b num=0
- Y% O+ R0 E1 |/ C* m" Zcount=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
0 D# F/ r" `- T% E+ C% B  Vprint(num)

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

count=1
while count < 13 :
4 o  r! {: c! R( h8 ]    if count !=6 :
  k: n+ r& Y' F6 c- L        if count !=10 :
            print(count)
1 `) h* z( n( q4 |+ N  ?8 L% E
1 [+ b) J2 @, A/ r. C& {    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
/ O# B4 c; K) _. |* R2 _    if i %2 != 0 :
  z$ [% j3 p( v# b        print(i)

count=0
while count<100 :
    if count %2 != 0 :
        print(count)
9 ~% h$ J# I9 b# t* V& O    count += 1
; T* g0 w3 Q! W1 N6 Q2 _9 l: K; q
5 ]. {0 j- u% Oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! T+ K- C# H0 C7 J    if i %2 == 0:
        print(i)
. p( p: p3 Q8 j' G
count=0
while count<100 :
    if count%2 == 0 :
. m9 O" r4 a" n6 K. f# U" `6 x        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
- @- L' w/ U! m  R2 K
print(bin(5))二进制   0b101
! v6 m3 _/ C$ F2 f# yprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
! X7 x8 r: t. g: o; a14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
' C3 z  U. i. s$ a, y17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1))  结果  3

; m3 p" v' i- N3 k$ Y$ I, k6 U
18、布尔值分别有什么?

False .Ture ,或1  和0

# W8 p  z3 e7 @( }! n20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
+ D4 P. L% K; _+ y8 I: j
% W4 c+ ^, u- |b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
5 a3 z* j. E( g8 Y+ ?c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
0 K4 g* `* N5 g' ~2 q2 aprint(name.split('e'))   ['al', 'x  ']  列表
0 u  s0 z7 `, `1 Q$ [
) f% d: h6 [' \& \- M% w2 Cg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
- S9 D( |7 {0 B3 I$ O4 N5 d; i& a
( C8 V! i3 H! j( gj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
9 ?1 T' @  z& u' j1 }! L, Xfor i in name:
7 T( G, h; j/ b3 F8 |) i; O    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
: O: X. H/ f6 U22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
5 l% Z! n3 |  e% xprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
6 u( s% m8 V2 `% m1 M$ o* Qprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
; v- C4 u( o" ]3 Rli.remove('alex')
) c4 j9 L$ E0 Iprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
+ j. Q5 f7 b* G, X# f$ B, t' H! ^+ L
& b% B3 }# K0 \. ]; r  ]) x3 R% Heric
2 l5 ~* {  D6 _+ z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
- k. z7 p0 a( uprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
/ p" j, V% Q% G1 V, H% Y    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
. k+ L" ~5 `6 H& I2 G. D3 X3 Zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
' o  @, n- m7 ]; B& ^8 Aprint(li[2][1][1])
9 l+ F2 N; {4 a! R% A7 Z( G/ gb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
4 y* f3 \8 b" k: ]li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
7 ]' a& ^5 D; V9 O% U$ Q: C+ ~b. 获取元组的第 2 个元素，并输出
; ]2 O$ S: O1 H& a4 K4 H% s4 Tprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
. P7 r" F) M8 N0 Vfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
* h/ U! k0 ]; l) h6 f- Q, {0 d" b6 `* dfor k,v in enumerate(tu,10) :
* m1 |1 h+ t6 S4 p8 t6 s: v    print(k,v)
10 alex
11 eric
4 `4 @9 X9 u, M3 q. D2 g12 rain

for k in enumerate(tu,10) :
5 p1 W4 z3 O* `; x; ]- \    print(k)
(10, 'alex')
' R# ~1 g0 t- V: Z$ }  S(11, 'eric')
(12, 'rain')

5 N. b/ h) [+ F8 a' J: i
0 C4 g8 o+ D2 H- [" H$ {( Q25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

" [1 f" u8 I( I# d5 \1 [$ Q$ Dd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

, h) }0 }5 y% F/ m* Z: [" \print(tu)
26、字典
) K: d( o3 g( |$ m9 T. \dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
$ z* W' ]2 m+ v$ K. a    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
. I3 }3 g# }2 W( X9 v3 p1 Sc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
% z" L' ^% x+ ]- h$ @3 l  {3 \print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
# j/ j7 _- l/ T" e6 l( }
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
# q% d( d+ {. d3 B0 l. ?print(dic)
* P& Z1 @. I) k27、转换
. s! b: [) f# Ca. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
$ b* w+ x3 F) Q, Ys = "alex"
8 B3 G( `1 L: n( o6 Nprint(tuple(s))

1 H3 C3 ^. H3 Z" Sb. 将列表 li = ["alex", "seven"] 转换成元组
* v( ^) x4 t, ?  @li = ["alex", "seven"]
+ \8 V# n7 U; ~7 j7 y& f. |7 Qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
4 R9 W4 h2 e; itu = ('Alex', "seven")
% `( c$ {8 R+ p6 @& ]3 p0 i5 d- c' Jli=list(tu)
+ r: [& G4 A0 ]$ r9 ~) rprint(li)


% n$ A2 }$ n8 [1 J) B: k" ?% ad. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

0 w. M  g- C4 J' U) @* P7 Vdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
% g7 y4 T3 S, I" ?1 H: V% r    dic[k]=v
; K; ~" @  e& F4 I    print(dic)27、转码n = "老男孩"
4 D9 @* c, r' s1 Z: Va. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 |% l% i! y  K7 j$ @9 Fa=n.encode('utf-8')   
print(a)
+ @4 O$ O6 k6 Yb=a.decode('utf-8')
: x: `! F( J5 X. U, ]3 hprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
9 Z4 r* a4 b6 v' b) jprint(a)
$ ^3 e" u" r  y9 V2 C3 kb=a.decode('gbk')
( U: v5 ~2 |0 X4 kprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
6 |8 G  ?* H7 Z2 X9 w) Ufor i in range(100) :
    sum=sum+count
( |& p  R/ |- ]8 ]    count+=1
print(sum)

count=1
& Z! V. V* R* Z( A- R+ Asum=0
3 F0 K& \* Q  R+ @7 Cwhile count<=100 :
( [, n4 X/ [$ }* m; d0 }3 I    sum+=count
, V" K5 Z: K8 ^    count+=1
print(sum)29、元素分类
( a* v# Y7 n% A- p7 {有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
$ [+ a1 z9 u5 P+ \# @* r% |将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ x# Q( Q$ ~. E* s% U7 }li=[11,22,33,44,55,66,77,88,99,90]
* R" Q' {( _  ]dic1={
    'max':[],
8 V. J$ P5 k4 N' E    'min':[]
0 D: d7 }* \# J2 v' p% D/ o6 X}
5 v: d# T: r" S3 \2 \for i in li :
    if i <66 :
6 ]8 U! m! V, R+ _8 v! {        dic1['min'].append(i)
  e/ g0 b# |) D% q* L$ a  u* z6 I4 M    else:
        dic1['max'].append(i)
' [6 w/ G* G% c1 tprint(dic1)
6 W6 a, A: Q% \$ ^6 ]3 @7 z( s
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}