Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

+ W6 [3 u* f; O4 _# H7 C( 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个字节代表一个字符，

% {- W5 `' O' X8 J* C4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

6 m$ t( ~/ L- u4 P5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
. h( V" ^8 T. _: p4 xprint(id(z))
) D) F' c! q0 @' D9 v# C' s9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
* G9 c3 S+ d% w& o. h9 aa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
: [: u: ~) i' P/ _& V1 R1 t    print('ok')
) _) P) F) ~( a$ M) @' C9 M3 oelse:
) {9 h3 y9 B3 j6 A. }9 U5 d' ^    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
2 A2 z0 [2 o4 Q9 D' G    name = input('name:').strip()
; u8 q- ~& r% V    pwd = input('pwd：').strip()
& ~* g* M" C* J0 e6 N
    if name=='seven' and pwd=='123' :
        print('ok')
6 `# @1 i% i9 e8 Z    else:
        print('error')
        count += 1
for循环：
; C' v2 N, f: N3 wfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
& f7 L: [& r% x3 e. p6 d
3 Y7 Z9 m. h: {% a# w. x+ M    if name=='seven' and pwd=='123' :
        print('ok')
1 D" p. j' M2 J& T    else:
% V8 a. l& H5 V+ q0 V' d! x; z( u        print('error')
& X% B9 E# I# b        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
* g$ u1 b8 k% ~  ~  g* dcount =1
. f0 h% i  o9 u( kwhile count<=3 :
5 r* b# i+ }# X8 i' p    name = input('name: ')
# _$ u" k6 E" l+ c    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 F, m+ ]! u5 H6 A1 Z, n$ J        print('ok')
5 q$ ^+ ~8 f8 H7 u    else :
        print('error')
        count+=1
/ ~$ F1 @% a. O4 b2 X; u1 kfor循环
for count in range(3)  :
    name = input('name: ')
" {9 F" `6 F9 i8 J2 g. d( Q    pwd = input('pwd: ')
4 y* h" K4 t9 V( k7 a; Z/ ^1 `* t2 u    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 E" J3 ?1 L$ h! T8 p- f" E) L! }        print('ok')
& `; i5 I; k6 E, D6 K    else :
- ?3 o! @* o4 Y4 R* b. g7 y        print('error')
7 D+ Y! l3 E3 V8 B7 Y        count+=111、写代码
% I7 u) p1 L' Y2 [3 Ca. 使用while循环实现输出2-3+4-5+6...+100 的和
0 s# s; b2 F% a3 g0 zcount=2
num=0
, d# n- ?: n( [9 b  _while count<=100 :
    if count % 2 ==0 :
1 U# P8 }  L2 H) O) w# W        num=count+num
/ h$ }; V: H$ h1 Z/ V, v        count+=1
    else:
' O: s3 P! h5 q. G        num=num-count
        count+=1
( t, ~$ u, {& R* N+ B. Zprint(num)
! w) F' y3 J7 ~
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
0 F. j0 j* q: icount=1
9 q1 q/ o  r/ A# H: @. l, ffor count in range(100) :
/ c7 i$ v2 [& [2 B    if count % 2 == 0 :
        num=num - count
    else :
4 t' u4 K: c3 V1 g" w        num=num+count
! g, h! [2 J) N7 C! c7 T7 t& B: V# l( |# Xprint(num)

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

) `/ B. Z4 C2 e/ x3 F3 ycount=1
/ H5 `: |: Y7 D8 hwhile count < 13 :
2 B) _* L  R2 f* t% X# ^( h    if count !=6 :
2 \7 M( j$ r, G/ P        if count !=10 :
            print(count)
6 x- P' A* a0 H0 J
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
, S" z) i( |5 z4 afor i in range(101) :
) u2 u% R0 N9 n) z8 ~- O! p9 J    if i %2 != 0 :
        print(i)

$ L/ P. Q  _. \" N* p) P. X% ?1 Ocount=0
while count<100 :
7 C. h9 A5 L2 I5 J    if count %2 != 0 :
" k" ~: h: _' u6 \4 }& Q4 f        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* }5 F+ r/ a* B4 i0 h. u9 z    if i %2 == 0:
2 H: L5 N0 {/ V        print(i)
; e& D6 B; t  g, l- S* q
& \$ y4 Q8 H9 ]3 @+ V9 u6 Wcount=0
: O6 b0 _. N3 H5 M. Ewhile count<100 :
1 h. J3 f( K- C    if count%2 == 0 :
        print(count)
1 `& ^* A+ J7 |2 o    count+=1
7 o. I/ `7 @. n, a0 Y$ d( }, c3 ^4 A
12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
& Z+ ~1 [% V- j1 zprint(hex(10))十六进制  0x5
; t( g( l" \; L5 D# _; Y- q" mprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

/ T. V2 q. u3 w' D& J' Q16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

9 U' b3 x& K! f  }* J  R$ @
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
6 a' l$ {  G% H$ c) [. h2 q" Va. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
: V% c7 _# E  @1 Q+ G
; c- H" N; X1 j7 S/ A. w- m/ ^b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
( ^+ F/ y  h$ B& ?print(name.startswith('al'))
5 S  {) d8 ?% c5 s+ gc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
' a# n7 @0 f/ U5 l- ?e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
6 p7 H( r  H9 W6 [
) @  a5 c! {% G; Y; l/ Cj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
. |1 W4 q& C! t  R21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
2 S7 J. O- w9 g依赖索引
, x% _( x5 e+ G& ~/ \: L7 n; Iname = "Alex  "
2 d$ D9 a4 v$ J% o  Ufor i in range(len(name)) :
0 g' W+ e4 t1 o# |! e& v1 U3 ~! }    print(name)
for i in name:
7 {) D' H9 r9 a& w0 o% i8 `    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
  Z9 c- b* R; _) C% z22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
% p7 S% K9 \! X% F# ~; Dprint(li)
, v% q  @+ F% n, @( y7 h7 a) ~ ['alex', 'eric', 'rain', 'seven']
9 [7 w* ?) Y. _3 x- Zc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. p$ @/ @& \2 u  [0 K1 iprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
, a- P9 U' Q* H, _$ L6 bli.pop(1)
0 g- l/ j( ]9 Nprint(li)    ['alex', 'rain']
1 L: P( r) e8 J& X指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
9 ^# n4 y* Q" I% J& \- iprint(li.pop(1))
9 t9 b0 R4 E3 q1 d5 tprint(li)
# n- g1 _# i5 [/ P( p- G
eric
/ _8 V+ y2 m1 ~( C['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
+ l  J9 @4 J3 r$ U) [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]
  ?" b8 s; C( D% aa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
/ ], I1 `/ n; {) sb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ w. Q' d5 M+ [. i2 ?5 W( Fli[2][2]='ALL'
print(li)
! ^" O8 J7 W% ?' G5 [: N+ ?! X) p3 L24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
0 S- q5 K' m/ c  q% Gprint(len(tu))
b. 获取元组的第 2 个元素，并输出
6 q7 H- H) G5 J% v! E6 e) Nprint(tu[1])
& V" P2 {6 X1 t  E" ~2 r- T0 Re. 请使用 for、len、range 输出元组的索引
# T- ], h) L2 X5 s% ufor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
, ^5 \! Y/ O0 V! f7 F; h. o    print(k,v)
  G; X2 |' P; J9 Y; |& \10 alex
6 w, o, c) I+ K, i7 J  y11 eric
6 A" y5 W# [4 C$ P# N12 rain
* H" ?/ F2 f9 v7 M
2 l7 G! P' Z2 N3 ?! [; d; n  C/ Jfor k in enumerate(tu,10) :
    print(k)
2 b! L9 u, h0 O( L0 C5 y$ E(10, 'alex')
(11, 'eric')
% h' L  W( n& h  t! d9 V( r+ R(12, 'rain')
% |0 J$ w# {6 A  _
, a2 x. x+ C' b: J
7 j$ N( r4 ~+ \5 p. K# @9 `# F25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

3 X6 E9 \5 A7 @" ^/ ]d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
, R# @3 U- ]3 \) i! G3 Gres=tu[1][2]['k2'].append('seven')

" i# r8 ]5 o. C. a5 S2 o/ ?, o- z" Iprint(tu)
; R! q% N( Q) C. n. g- J26、字典
3 X# u7 t$ d2 O( H9 C6 j  q0 Bdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
4 U; m( Z! F" wfor i in dic:
    print(dic)
  U' w) O9 {2 g9 A  L, Qc. 请循环输出所有的 key 和 valuefor i in dic:
5 T  R. \# o) {! E; H& {: r0 R$ U* E( m) x; ?print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
. j, F& r& P" ~! [/ J! @dic['k1']='alex'
9 Z7 }$ ^6 K2 B! X) dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
# F- f! U3 J2 F3 G' c- k8 ~3 Lprint(dic)

. ?2 F& q; @* vg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, M5 d. P1 `. `# Q: F3 P' L3 kdic['k3'].insert(0,44)
: e; k* m. r( pprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
9 I+ C) z# q# l. Hs = "alex"
& f: j- N' \/ a/ Oprint(tuple(s))
8 I5 L, c) ?1 O6 h7 _3 Z- Y
b. 将列表 li = ["alex", "seven"] 转换成元组
8 C6 [3 v" e5 R) `) R) {: j  |. Yli = ["alex", "seven"]
& n; F" r$ Y9 o$ Xprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
) r2 Q- d( ~; Bli=list(tu)
print(li)


d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

1 N- z9 t! q7 }% M( H- g/ x4 Tdic={}
% J& F( q4 M9 _7 R+ Vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
* X! l% z* ~  s9 p4 G, Y  W% f, i    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: ~9 a0 _& G" Oa=n.encode('utf-8')   
. [- w5 x1 [7 k: g" W/ m- Z) S$ Zprint(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
' ^) D% _% \* P- n, u7 C4 _! O' ]print(a)
; c6 v( X- w$ Vb=a.decode('gbk')
$ V8 \! {6 t5 V- a9 eprint(b)28、求 1-100 内的所有数的和
; h0 |! v1 S+ t$ Q" V8 @* D% q9 gcount=1
/ `( \5 l1 k8 Hsum=0
: C  w( Q* t; F3 q' I" Wfor i in range(100) :
) Z$ x$ T( U: j' \    sum=sum+count
    count+=1
5 X: |: E( i* J+ {- qprint(sum)
' L' O& g& R" O& ]
( T$ q/ B' @  a% D' N0 g* U" E( M1 s: `count=1
5 c# s% S5 J7 E5 ysum=0
while count<=100 :
  H7 j1 c  O  P/ Q/ }2 b3 w1 ]6 N4 E7 e    sum+=count
    count+=1
print(sum)29、元素分类
5 d% y) H" n3 U( o  I有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ U. q3 x; m. G/ L$ z4 T' A# I将小于 66 的值保存至第二个 key 的值中。
" i( B2 q  M. x/ U8 p& T: ?8 l即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
5 i. z5 [8 V" u# r8 s/ odic1={
    'max':[],
. s* ~7 h' n  o    'min':[]
- e& _- G) Q# N& u$ G}
for i in li :
    if i <66 :
% i) F/ Z5 k; f        dic1['min'].append(i)
    else:
& b4 o1 h1 m7 B0 ^        dic1['max'].append(i)
* r* N, V( N6 M. u9 c" w/ Pprint(dic1)
1 c. U6 Q8 D: a1 U/ e* [; P5 ^
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 S: `/ T0 M  F, v3 \