Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

2 ^, W; c+ `3 w  T( [$ g3、简述 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 N3 k; f: b+ j3 G: j' N; ]4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

0 ~4 `) u2 b+ X2 a5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
- j4 K1 |& z- ^2 ez=1
7 _8 Q2 M' A% j6 r5 E, g7 f" m* [- qprint(id(z))
9 i9 o2 D# u9 @/ y$ f, p% C9 t! x9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
$ ]" o- y4 M4 Q; F$ L2 Opwd=input('pwd：').strip()
: ]6 y3 W6 w. g/ o6 x. yif name=='seven' and pwd=='123' :
9 N' h+ ~! h; l  y' }6 ^    print('ok')
% c# P& H6 }$ n; b: m" }else:
+ n9 i. \: h  E    print('error')

- H# s6 R9 m; h1 ib.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
# W5 c2 ~/ f; k) ^6 |: l; Dcount=1
while count<=3 :
    name = input('name:').strip()
$ K- Y: F% c, R. B    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
2 j6 V' z8 F9 ]# f( ~; J, U        print('ok')
    else:
  q$ b# `2 N8 U. @& Q. C        print('error')
+ l# t$ d) ~; D; _  r0 J8 p        count += 1
for循环：
  o. c# R6 C6 I. X- V% h4 @: H& H, \for count in range(3) :
$ t& ~2 T6 @  O6 s  K, h& P. M    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
0 f! C: j) }$ b" g' d        print('ok')
    else:
$ v* A: v; H* x( s        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
1 u; @. D1 ~  q! ~$ {count =1
) \8 f+ h2 o- j  S" [5 ^2 {: Fwhile count<=3 :
    name = input('name: ')
5 d0 Q# I: N( V$ E5 n9 B) _    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
2 B/ Q' ^  g7 S9 V    else :
        print('error')
3 i) h6 V: o* L' E" ^; t        count+=1
5 _* r. w8 H+ |! g4 m1 U$ k3 [for循环
) r4 R& n& v0 p0 ofor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=111、写代码
& }/ L! p; a: l% |9 _/ D- oa. 使用while循环实现输出2-3+4-5+6...+100 的和
/ s  D) m) u5 Q3 f: Ecount=2
num=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
. @) P6 t6 G1 ]! v( l/ C8 q        num=num-count
  ^% m1 k0 _; E3 [+ H        count+=1
- G& ?# I" R/ @9 T- n; D' @: ]; Vprint(num)
# R% X/ ]2 T7 F# B( L8 ~4 h
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
. k9 q" a/ m' J6 S9 Z num=0
7 r( o& b0 Z$ I4 t) s* ycount=1
% k* Z9 A$ G( ^' M5 C1 F% B& ffor count in range(100) :
    if count % 2 == 0 :
( T4 u/ A; h# K8 {' ^, V6 s        num=num - count
    else :
        num=num+count
' D& e4 @1 P+ p4 @8 zprint(num)

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

3 N3 P* p. i9 x; G) jcount=1
while count < 13 :
) t: O- Q9 F4 ?  d! ]    if count !=6 :
        if count !=10 :
2 i9 u1 f$ M! Z' z! z            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
* M2 Q5 {  K0 a8 V( ^
count=0
while count<100 :
8 b9 `. B% m( p    if count %2 != 0 :
        print(count)
    count += 1
0 y7 P7 @8 }( R4 N+ d7 ]
5 J3 t3 k  i% r% ~" e1 le. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
2 P/ x: ^6 e  b7 s    if i %2 == 0:
        print(i)

! `/ g! M; t( J; d' }9 f' `count=0
3 W& O2 H9 {! F* _  ywhile count<100 :
1 S/ v( S" k% K# y. k1 P    if count%2 == 0 :
3 z1 v4 a7 f) Q( b5 t9 y        print(count)
    count+=1
4 r" R+ Z" X0 }6 E- J3 I0 T! A6 S
" _7 B, x! \8 b* j12、分别书写数字 5，10，32，7 的二进制表示

( K: F) P; }7 y# y9 B  P. wprint(bin(5))二进制   0b101
8 e! f/ y, C+ k5 Y% B9 v1 Vprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
4 D5 `' y0 V: \) z! c) L17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

( _. n6 `7 `, _20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
2 U5 @( A9 E$ m8 C2 P" b2 P9 w1 dprint(name.startswith('al'))
( a% t2 S2 L" S6 Gc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

& W) y" D+ T) M2 R, v8 ug. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
& }- p* Z1 z' d& f
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
+ p, k  O5 m* ~2 N. N21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
$ F: a1 v# W6 s( C! B% Q- R依赖索引
: {8 _' ^3 |; ename = "Alex  "
for i in range(len(name)) :
% [- |+ r- ^! J  P  D    print(name)
2 m# ~7 y# E$ [, kfor i in name:
! ?$ D- g2 L5 c; a8 {4 d& 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']
# ]& [% S7 r9 C& r. R' E+ Bprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
$ S  I$ y: K/ B# v4 J5 s  tprint(li)
0 n' ]+ d" L3 J; q% ~" i, R( e ['alex', 'eric', 'rain', 'seven']
1 o) P+ D: {5 Mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
4 Y4 U- R" ^7 C) y0 Z* ]print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
1 m& x" G; X! t' @& N4 W+ Bli.pop(1)
* }/ g1 F; `3 @4 a) tprint(li)    ['alex', 'rain']
4 |2 `! ~5 ]3 b) m8 i3 t) J; g0 Z指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
) o5 D. z* ]1 y4 e6 y& Sprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ X- z" J, n" w: B" E, E9 Rprint(li.pop(1))
print(li)

eric
8 g2 ?# l8 i& r9 T* V['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
! g9 b/ M7 U; w8 w9 l/ H! ?li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
) C3 n8 q" s- T( f- y2 O! _1 Fli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! a$ ^6 f+ ?; l1 r% a3 z2 Eprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- l  h1 [5 v% L5 M1 ]li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 f, q8 l! h4 ?0 G& _. Y+ F$ }3 W# Pa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
, m# p: D) [1 t& o5 J2 V9 V: s$ kb. 获取元组的第 2 个元素，并输出
; B: E/ ?' r/ o0 m* I9 [* lprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
* p/ a; {. d8 \8 N! O9 o$ xfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
" I2 k* B) d* q( t; k5 y1 ], b# T% n11 eric
12 rain
+ v5 Z8 Q8 n; N* g  @5 i' F9 G* [
for k in enumerate(tu,10) :
$ D- f' G2 D# ]2 X+ z    print(k)
. a2 L3 Q+ d8 @/ |0 z: E(10, 'alex')
(11, 'eric')
6 o2 n' ~% J7 q(12, 'rain')


1 [2 _# `: R3 B7 W9 _5 P' m0 N( a25、有如下变量，请实现要求的功能
7 |+ U: X, j/ Otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

" E5 K1 _+ B) @: k. i& T( \+ Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 B8 `5 }/ W" j% \8 ^9 W, dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

& C4 G$ E1 N0 E3 C* h" T: E5 c3 }7 Eprint(tu)
9 z0 h2 B. m8 ^26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
: G$ W9 F9 E; z  x4 y    print(i)b. 请循环输出所有的 value
9 ^' f6 e& n7 A3 A1 Z; P/ cfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
) @0 p/ g4 ?5 c+ X: L- eprint(i,dic)
1 n6 x, r5 o( i, s+ Z+ [7 hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
6 f  ]* y6 J7 T0 d& ~* i5 D% {print(dic)
' Y8 j6 ~) I/ Pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
/ R7 `4 y/ l4 P( Y) |( n2 o; l2 bdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
" d: n+ y  h3 J6 e/ p; qprint(dic)
# a3 \7 F  a2 y8 M! ?5 S' H! |
: U( ^. C( r6 q$ ]+ N. f1 |g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
3 t2 @' u0 R+ V% E1 |  K+ Mprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

& C* l+ D  c7 iprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
; V9 X+ v- ?0 M) P. m' J4 Nprint(tuple(s))
6 u8 j, u0 O& Z+ }
b. 将列表 li = ["alex", "seven"] 转换成元组
! o4 h1 }3 }/ pli = ["alex", "seven"]
4 f  G; ?6 M% o- Kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 m2 S" T& p0 I# `tu = ('Alex', "seven")
% L( T: v) c  u+ Q9 fli=list(tu)
print(li)
6 ^' ]- f8 \' a1 B- Y
( D9 z5 ^6 e: i; j
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

: @' n/ R0 H& `: l0 n2 Xdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
, l8 H2 r* S2 r& y1 n' D    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 |' S" r+ g' U# |( Ea=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: R; w. N. _9 v; ^print(a)
& u7 X) v& g) V' }$ nb=a.decode('gbk')
9 v+ Z$ u/ M" }; }4 H1 w2 H! [print(b)28、求 1-100 内的所有数的和
9 n0 E5 |2 R, V) X1 r! `count=1
sum=0
: P( {  D# Z# \. t4 Zfor i in range(100) :
- E: ~" O8 x/ L4 s! O" Q+ A  d    sum=sum+count
7 Z8 Z8 d0 s5 x. j" v4 [# m0 X    count+=1
2 r! g9 }! e' f1 f, ?print(sum)

: r' Y4 c( C6 y2 p( b1 ccount=1
$ a0 Y2 }  c% w5 ]1 `sum=0
- _3 g0 P( }$ Q# C$ c) R5 D- ~while count<=100 :
    sum+=count
    count+=1
print(sum)29、元素分类
+ c( j' k8 P3 U7 {7 n( i6 `有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' @1 e3 s$ k( |$ q' P3 R将小于 66 的值保存至第二个 key 的值中。
) w1 }6 {- H1 m- o1 \即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
) b/ Y' e2 z# A9 {li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
}
8 q9 ]! ]  O1 vfor i in li :
: N" W3 U/ T+ |' X7 |    if i <66 :
        dic1['min'].append(i)
3 T. B+ P# G8 H: _+ p# V; J, g    else:
+ S, s3 C7 |5 D. B7 C% S, r        dic1['max'].append(i)
* T1 X1 b* I8 o" r5 R% Bprint(dic1)
# c& O& x# Z2 f
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
$ l# j9 `  L5 M