Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

3、简述 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、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码. P) ^3 |! I1 _, e" ]( L- V: k7 E' {
a.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :
- g. d3 X0 }) g5 M* [$ U" I: s3 \ name = input('name:').strip()
% _7 d( s. {& F% |+ W9 M- ?; J2 A pwd = input('pwd：').strip()
% j4 S- e: g* l. R$ \9 W4 A% B, n- n) Q# |) p
if name=='seven' and pwd=='123' :* Y  r8 ?( }8 Q# A, f. z  d. I; D3 `
      print('ok')
& q; D7 X1 J: D& p4 W1 E# ]; ` else:* D( X2 f& x5 q4 K% _9 o
      print('error')  p9 t# B! e1 ]4 _3 t- s
      count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=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+=1
for循环
for count in range(3)  :' V% f( D3 Z" n
name = input('name: ')
% {, P' E( _2 T5 x6 }8 M& r& s5 G pwd = input('pwd: ')
  ^& }% _) H8 ?- G" f- h" k if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':! c, [' e: ]* M# I
      print('ok')
! z; {7 W8 L  H- s else :& D5 ?5 T8 J: h- o; G2 i
      print('error')
" m6 Q6 l* o' A) x7 D* s1 I' g5 H       count+=111、写代码
' g3 \5 L) n9 ^3 a6 `a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      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 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
& m; n7 G* d/ _3 ` if i %2 != 0 :
' N4 r: a7 W9 s- ?& M! r       print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
7 d, O$ G0 q! L0 X6 `1 l if i %2 == 0:
; F* i4 u: I* M7 s       print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制 0b101
print(hex(10))十六进制  0x5
print(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

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"2 ~, s( W6 m% \( D) O2 J: Q; o  p
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 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  ']  列表

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

j. 请输出 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)* Y2 z* W8 f( V9 p
for i in name:
# I. Y9 n' G2 [5 [, p5 g print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain  U" t' \# r0 R# X0 Z9 H1 w
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- Z( }% s- N1 g9 _) k/ ?" e
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 M+ X- a) w6 Y
print(li). U& t# L0 x: S& @! d7 f2 P
['alex', 'eric', 'rain', 'seven']% Y1 x- r: ^5 F  Z! N
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')6 x! }. x7 P. h/ L) o) Y
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')" @2 p# n' b2 w1 e
print(li)7 k3 o8 J) z- x8 I  @5 B5 d6 h( F. P/ X* M
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
2 A4 [, X+ M, m! b; \: ~2 Oli.pop(1)
5 d+ x5 a  ]# T+ P8 ]print(li) ['alex', 'rain']
( m/ w! W  p( e9 B指名道姓的删除li = ['alex', 'eric', 'rain']
' t. G0 g0 ?, ~4 i: x# [li.remove('alex')
2 n- e( Y: U! ]# sprint(li)
2 r7 V2 r9 A3 a6 _( ?4 p6 if. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ l" T7 B+ N( i& J+ aprint(li.pop(1))
7 C8 h8 _6 x6 o0 wprint(li)
5 B; ~6 `2 y: }/ e0 ?% _5 C0 z) ?% i; |, Y3 Y$ {8 Z. c
eric
& I$ y. R% B, w, W. U' X['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
* ]: N5 n! b4 C& Jdel li[1:]) _; P; e, p* g! c
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始), i* H. \9 C7 g! ^, S8 T9 Z3 X* \
li = ['alex', 'eric', 'rain']
$ U0 g: m+ C5 W* H& c* ?# ifor k,v in enumerate(li,1):
# M0 S' I+ j8 A; M; @5 C print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- l) M! X7 P* h7 Ba. 请输出 “Kelly”% Y6 m" q' ?- v1 N% q" \5 ?5 `; R
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 I5 Y4 B4 v% ~+ F2 T3 ^" w! C
print(li[2][1][1])8 x: X# B, e  d% ^! o4 N
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”, e" u9 A) M/ ]' h
li[2][2]='ALL'* R' q7 h- r# s! v) Q; `  O: u
print(li)
/ w) Z' n( U5 O0 Z; p' x3 ~* Q24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')1 [/ V8 H8 ]$ J# U  F# v2 w
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 L1 K7 u! p. M9 k& lprint(len(tu))
4 z& X! \; T! ^9 R% a1 Jb. 获取元组的第 2 个元素，并输出9 P( W) |0 R" i3 }/ b
print(tu[1])
* y/ v' T  N; |" Te. 请使用 for、len、range 输出元组的索引
: {, q" Q5 k# w+ U& @8 G8 _for i in range(len(tu)) :# v! B5 \# K) H. F6 n7 o* q. M: L  x7 k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
+ B7 V# O# b' C! @for k,v in enumerate(tu,10) :
7 o& H/ b5 o. x: Z" q0 T print(k,v)  f  `& c1 }, @, J' A, l. z
10 alex
4 x, E) j: B9 Y11 eric6 k7 x/ A( N2 f+ g5 Y- H; K, l8 N
12 rain
' J' a: n5 E$ X6 ?/ k; ~
, w* j- U7 Y; {6 ~' ~8 d3 _for k in enumerate(tu,10) :, f6 I; P5 K% y
print(k)
/ w& V/ k3 o) ?0 Q4 Q(10, 'alex')
4 T4 ~& E( t+ C2 l(11, 'eric'); [7 A" D4 r( N5 a
(12, 'rain')
/ N/ Y1 @4 p, C9 Q' y7 u$ b8 B/ ^5 J/ d" {
+ ^: _0 e6 d# W- ^) G) l$ ]
25、有如下变量，请实现要求的功能
* X* v8 H5 X. O. R& f% ^' Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

! T2 ^- G: e! L$ W: n2 md. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以% d; I' `+ U0 W# h( ~
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  a4 G/ K3 {7 U$ U' R* mres=tu[1][2]['k2'].append('seven')! g& ]$ R* u+ x
  D% c* G0 a+ _* O, e
print(tu)
% f4 `" V2 s; h* R% u26、字典" Z, Y. O$ Z5 Z$ _' Q* ]  c
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 y6 D/ I; M  x! p. j, d print(i)b. 请循环输出所有的 value
0 m' N8 a, |6 o. }8 u( F& cfor i in dic:
! i4 }' u% p0 Z. ~( Q print(dic)! |  N! O2 z' X1 P' Q% ?% a
c. 请循环输出所有的 key 和 valuefor i in dic:# E- Y: m: b3 G# z5 R2 Y1 ]
print(i,dic)
3 e7 H; S- _+ J& D/ Q4 ^: kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典( |$ G" @8 O1 a$ w8 v
dic['k4']='v4'# X: _0 }9 R, z! J# W7 |
print(dic)
2 [8 r! [8 x2 Y9 K) z% M: Te. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  ^; i' `8 _) a$ O; w+ M
dic['k1']='alex'/ s/ ^  {% h& K7 I
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
/ Q  r1 v6 P6 X. Gdic['k3'].append(44)
! D; o  i, v# n; T% F* G7 jprint(dic)* K5 S. T, W% Z3 Z. ]
: }+ M) A1 V  Y' b
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, ~2 q% t# F* u. `
dic['k3'].insert(0,44)2 @! D0 J- X0 {/ N
print(dic)
) }& S2 P: j1 m/ S, V# O1 Y1 `27、转换; [5 v! I2 |# r3 }- I8 T
a. 将字符串 s = "alex" 转换成列表  s = "alex"
" `/ ^& r! n% u* A4 t5 F2 \9 O' j" n+ c9 g6 W
print(list(s))b. 将字符串 s = "alex" 转换成元祖5 z2 Q, Y+ z4 `0 y
s = "alex"
+ S; |: h* \: ~  U- Y0 ^! ^. [print(tuple(s))
- G9 B( B* V( L/ j
1 ]/ b) Y9 v9 _1 F" d: }b. 将列表 li = ["alex", "seven"] 转换成元组
" X5 Y6 E% G$ c! [7 p! D6 Mli = ["alex", "seven"]
. E7 L# o0 \1 F! aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 G4 {) W" Z9 Xtu = ('Alex', "seven")2 ^0 V* I" l& c6 N8 X
li=list(tu)/ J5 ?% i2 ]3 H7 X9 Z- ]8 |8 ^# @) P
print(li)' P% J; [% {2 `) }
) U* q, @* T, @- W9 M, B
, L1 k! \9 Y6 l5 l: S
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
5 H$ d9 V- V3 ]: K' s! _
9 l' A, b/ x( ?, q- h0 R) }dic={}
0 g3 S- x9 F; e7 H4 n% jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面) t9 ~& x& h9 @% D2 c0 V
dic[k]=v
4 x6 {7 v( ?! i  x print(dic)27、转码n = "老男孩"
, x* E1 o& t" x) W$ d$ O# ?a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"' o% p2 l5 z+ R/ ?  D' f" `
a=n.encode('utf-8') " v% x3 y6 F2 o/ Q
print(a)3 j- A6 r# O! o1 O( o4 S) C
b=a.decode('utf-8')
2 U4 p! X/ }7 h& i! R" S0 t$ Dprint(b)
* ]! o3 ?/ O& Bb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')7 s. {* C: x  F  R4 }
print(a)1 f9 f. o" E2 l6 q
b=a.decode('gbk')& ~, o( L( b/ b+ O/ l
print(b)28、求 1-100 内的所有数的和
( T/ k& R7 C: G7 ]  Icount=1: d( V$ L: j: D# o- K5 l
sum=0
2 d$ H1 ^, o3 |for i in range(100) :! s! r& F: o: Y  i
sum=sum+count
2 I5 E0 L" R  }1 s6 c5 [% F0 t count+=1; Z6 z1 X: Y- ~- Y
print(sum)7 {8 m# G& @  D5 |
+ D* h1 o5 h' E2 L, ~
count=1
, D1 x# k+ X& p+ U9 K7 msum=09 z6 b6 Q/ }: \( j+ G: H
while count<=100 :1 ]. d. u9 L  X9 `/ C9 F& X
sum+=count5 k* e/ X& V3 X  i& P# y4 d
count+=17 m5 C2 ?5 V0 d# T
print(sum)29、元素分类7 ~8 y! u! y6 `
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: R9 _9 c  E5 U: [7 G将小于 66 的值保存至第二个 key 的值中。
: i6 s0 `; Y9 t. b$ S' K即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}* P4 S# V3 Z  B* s9 C% r: t
li=[11,22,33,44,55,66,77,88,99,90]9 O5 [$ H8 u& ^5 b
dic1={
; F3 w0 b$ f- ]3 e& r) X 'max':[],
) P) A3 j/ ~9 v# ` 'min':[]
; N, A* p* R/ r}/ C( ]5 V2 Z: ?' ?  I! H' A, ]
for i in li :
# d* B$ F9 f( A if i <66 :, F- ]% K4 j. b& r- `
      dic1['min'].append(i). N6 q/ w/ I8 K& L0 ]% ]8 t
else:
7 h3 a3 F' c3 B5 h7 f/ }1 @2 V       dic1['max'].append(i)
$ o3 s% j* y9 Wprint(dic1)
; R1 Z7 \' X* M( H0 M7 K
5 V3 F  y7 U# K* I! ]---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}9 L) H/ E  S- H( h# _) d0 C4 a

Python基础知识汇总

主题推荐