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、写代码/ O1 i, T5 t" i& S/ V+ h2 k: D
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) :
6 J1 |3 Y) S7 J+ x3 [" i1 ` name = input('name:').strip()
7 M  Z4 Y, N  {- H' y' h pwd = input('pwd：').strip()
/ L" @  Q/ n0 b( ]3 E
" z3 K8 ]$ ?, g& r if name=='seven' and pwd=='123' :6 x8 n6 |7 j  z& V2 R
      print('ok')
, P- d) _- ]6 r$ j3 f else:# I: ^# ~8 m$ k7 E4 }2 X
      print('error')
1 H* D+ x) O$ ~' a$ H       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)  :* @, e) y, w6 }+ L, c7 p, S
name = input('name: ')
5 I" j* f. g1 M3 `# U pwd = input('pwd: ')4 f6 O. Y. z" b3 [
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':" u5 N. n( @. a7 l
      print('ok')
5 [& v! W3 B) j else :
& C+ _. m: I- L* o2 N: I       print('error')2 d5 o) S! i. r$ T4 {
      count+=111、写代码6 x- A" O4 X6 N( q8 P2 @. S8 h. F
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) :2 r+ H+ v" k/ k* E4 i
if i %2 != 0 :
4 G' l* F/ z4 w# y+ W: L' F       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :$ D2 m- }3 |0 n  R, K
if i %2 == 0:
& l3 g2 C) H& a9 T  R8 [; o       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"
( l  N( Z* [# R* d+ X, p6 q+ Fa. 移除 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)$ P4 B! `- Y$ H4 G) O
for i in name:
8 f6 f1 r3 l( A% }) W; A print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
4 \% g3 v0 S. {1 o22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 D" [: f' z% {2 Bprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
( z7 i# L1 ~7 _( F) W' ?print(li)
0 j1 G+ P+ c$ F5 h! h) l' e ['alex', 'eric', 'rain', 'seven']% z; h: M( k! y$ |4 R& m
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( Q3 [! P: d9 P) Rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')- |7 i4 V& Y- U
print(li): K' D% e8 t, H
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
' X" c, z: e6 k4 Bli.pop(1)
6 @* j; o3 ]% Q, C. |print(li) ['alex', 'rain']6 s4 q) T8 O$ j/ U3 W$ _7 W4 v% v
指名道姓的删除li = ['alex', 'eric', 'rain']
/ G# q- w: Z& H4 V3 w/ d1 X( f$ Dli.remove('alex')
1 K9 ^7 z3 r* L- D0 Bprint(li)
7 f8 C  Y. u" w" @5 \; l( U, Jf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 H$ @% T4 v: H& @2 Dprint(li.pop(1))
4 i8 W4 K8 q, }+ P- P! Lprint(li)
: n. Q: g( L/ e- [. |2 x
" d! `" m# l, o; }6 k  Seric6 [8 f: m  Q$ \
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  M' x8 G8 z& X: T2 |9 v* f6 kdel li[1:]% q: o* J# P8 n( u/ l3 Y, |/ b
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 W* Y  L& A3 qli = ['alex', 'eric', 'rain']5 n, S' x- O2 z% w
for k,v in enumerate(li,1):5 r( r# S4 P" E% V' J
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 Z2 q) d% \  p/ c; ?, v  ya. 请输出 “Kelly”( I) Q5 O+ h( u6 u
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]" d+ i3 d& H2 \5 ^
print(li[2][1][1]): G" T) C* r8 G' I6 i+ f( T, Q
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”& ?; ~! F, W- k- \/ ?" T" j
li[2][2]='ALL'
; r3 U: B' U" X+ o2 i0 g6 H& s* Oprint(li)
8 F* g9 U: b+ q# q8 n" I24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
7 k; k& [* N/ r, s1 fa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ K. y! a" i! Y4 {6 B4 Lprint(len(tu))
7 @1 g# b+ h1 s9 v. [$ S$ ]b. 获取元组的第 2 个元素，并输出
4 o: d  x# ~/ I- T/ tprint(tu[1])
9 L% x1 n! X' a+ {e. 请使用 for、len、range 输出元组的索引0 t3 C! c! M5 E
for i in range(len(tu)) :
% ]: Y3 A7 U' H2 {9 H' p) A print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始). X2 g2 }5 t1 v
for k,v in enumerate(tu,10) :  l( x7 S3 r( B: N4 O7 f3 K" e* H/ v
print(k,v)5 A. P( P. ^6 z9 d8 R
10 alex
. Y9 G/ o0 V5 M4 m9 ?' C, a) k11 eric
; B6 q7 S* d* q2 V- d2 g+ O7 c12 rain
! x1 |+ Z0 O4 }5 i
7 o, O) R" d/ T. q, Yfor k in enumerate(tu,10) :2 G7 g+ f1 a) D8 A" S2 k
print(k)+ F+ K0 j) W2 y' Q
(10, 'alex')) ?* k  R: Y+ M( u, j, [6 Y  K
(11, 'eric')
6 C1 Z$ ^8 ?# }( H9 G, ^( e* @(12, 'rain')
# N  j% }, U( q* [- X9 h
( |7 B8 u( }# A+ u
, @. v+ ~& E5 W/ O25、有如下变量，请实现要求的功能( j( U. A" f! I- ]. z/ m) K! D% V
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

7 T$ A6 f4 M0 U5 S$ i' ~! n& md. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
- O7 G) B* k# ^- G  S' ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
2 S) [- q. U  ^/ r5 bres=tu[1][2]['k2'].append('seven')- [* h6 p0 E- S/ `& I
# u& w* Q( d1 v  @( K9 O4 ?
print(tu)+ a% G% e  c" v( D* z
26、字典# y  r; G9 J0 L8 v/ J
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
0 |: f' _9 U6 p# d# h7 R1 f! e print(i)b. 请循环输出所有的 value) y9 z: s1 z" M
for i in dic:( k# u0 K9 `# \9 N
print(dic)
5 D" V7 V6 `" n" Qc. 请循环输出所有的 key 和 valuefor i in dic:5 M+ ^1 [3 e7 ^" h9 B' ]
print(i,dic); m! O. e# i) ~( G- e$ q
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' J1 ^; }' R+ ~: h) Tdic['k4']='v4'
$ x5 L/ _% J: \; Q0 t" I8 o' I. h* xprint(dic)
; F" D/ O, h% J& D; |5 v3 `e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典; A7 T; _$ J8 B. m- U; B2 X2 Z
dic['k1']='alex'
* b. P1 r9 _4 bprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 `# P2 c/ b: H8 Z8 ]' Pdic['k3'].append(44)" b9 N0 T) J) P
print(dic)+ {, A7 i: I* t% b/ i, A
% y/ t7 d; q7 F1 A# @) I9 Q
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- g7 ~% M% A9 n$ ddic['k3'].insert(0,44)
0 n1 m% o2 i8 [$ ?9 nprint(dic)
, n5 v5 h! C% R2 r( m27、转换
1 Q2 `& s  H0 ^: j8 l8 Ca. 将字符串 s = "alex" 转换成列表  s = "alex"$ j/ Y+ `  ^4 t

* a9 L- j5 t4 u/ Iprint(list(s))b. 将字符串 s = "alex" 转换成元祖3 g$ N* p3 e" L) m; Q" t' c# {1 h* M
s = "alex"# s$ ^! @7 s0 X2 D5 \8 o" K
print(tuple(s))( v  b0 _+ F3 P! Q# z) W9 y$ c. C

$ S3 w) a7 ?& \7 a* Gb. 将列表 li = ["alex", "seven"] 转换成元组
. v) C3 p0 O4 ^# F6 w% Kli = ["alex", "seven"]+ k! A7 g" n! I; h- @
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
! j# q& R/ v! |( _: ?; p; Ktu = ('Alex', "seven")+ H/ y6 t8 R3 n" G- r* g0 _0 Z
li=list(tu)
* `7 U4 W3 n; |+ E& F' M9 \print(li)
6 s$ u9 q% t6 `4 O* e
6 r' A$ Y2 x- y: j, U3 c, f0 |1 |$ {2 j; [6 r, Y
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
+ w+ Z0 ~& w' E; X
3 X+ f+ k7 a: ^, r* W6 _+ K5 W$ odic={}# g5 r: R& V# Z, G
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. W$ N) h7 {; F dic[k]=v5 h) U' @6 G; R' o
print(dic)27、转码n = "老男孩"
9 H: I- d$ n7 l. z! S8 Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, Q9 v" I+ A6 U0 _a=n.encode('utf-8')
" ?; a. \$ f4 |" rprint(a)
# k4 a8 X8 Y* r! s: L  l) Y& cb=a.decode('utf-8')
; I' l* Y. h6 r* T8 f" G% e4 _, y9 lprint(b)
/ y0 s' ~5 S, }& n: ~. Xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 h; u; T" Y$ t6 U
print(a)
2 I. V0 {3 I) y4 F! ^6 Ib=a.decode('gbk')  b; r  g: a( n+ l1 A
print(b)28、求 1-100 内的所有数的和9 A  i- `' E6 L: [, a$ S, K( p/ g
count=1  ^) G% u& d; W. S5 x  j' b
sum=08 G$ Z# o9 w: G$ N
for i in range(100) :
0 y) O/ Q8 X, D) r& ^8 z sum=sum+count4 p% S" G2 v: }, U& F2 ]: b9 n
count+=14 k) I" L& y3 c& v/ |) q
print(sum)! W- }4 ^+ B1 c( `, g( F0 ~

6 A+ S3 j' j. v2 P, h+ Rcount=1
# M6 X1 ~6 j  f- E( Csum=0
" Y' \. z, k1 j7 }: S# }, cwhile count<=100 :
sum+=count8 j$ k6 U; l7 ]& g* B5 s
count+=16 e* d6 ?. c8 b. W+ |
print(sum)29、元素分类
) w9 d& p5 l. Q% N- m6 L2 b有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ ]$ d+ z- j% g将小于 66 的值保存至第二个 key 的值中。* w/ m$ ?. x3 i! U, x
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
, n; m+ Q- M2 e5 ~! z) N" wli=[11,22,33,44,55,66,77,88,99,90]* ~# }. g3 f9 ]- t
dic1={
/ B2 w) J3 M( i% g& Q- k- z 'max':[],6 ?8 b1 [8 R# `# Q
'min':[]
, }9 i9 S9 h% f" e' [3 K  J}
$ S. |' V, J, N' Ofor i in li :
; h7 c, ?# x. Z- {; E if i <66 :
. H9 c9 A2 O; o( `" [& \       dic1['min'].append(i)
" s" f4 N$ D0 s$ }7 ]9 p else:# U- F' o; A1 e3 S/ m  y
      dic1['max'].append(i)
$ N" F) i' @# v: u  y/ ?3 Kprint(dic1): Y& c1 s  ]% [, Y5 C/ n' S) E* p9 n

6 `  D0 k! I0 d& U5 o---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
' x! J9 }0 U$ O( I# R

Python基础知识汇总

主题推荐