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、写代码* j$ M8 e/ ~% ^: S
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 w% \; V) [  V# w8 O5 k name = input('name:').strip()* B; A# a0 c3 ~4 {
pwd = input('pwd：').strip(): G3 Z/ R. s8 T. y3 ]2 C) A& O

7 M1 e5 i) }% [" i" ]: ? if name=='seven' and pwd=='123' :
' ^( P5 `: [$ _/ B  ]: Z+ Z  ?" o       print('ok')0 X& n' P% k+ S; y$ G4 g9 X
else:
8 m3 S4 {) `( K% X1 V$ p       print('error'), E9 z  I8 D5 x% u7 g) y: k
      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)  :% a6 L7 m! U$ {) B- P+ `
name = input('name: ')
' q( @0 S5 J. j# I& x. { pwd = input('pwd: ')7 k" o% [" n7 U( E; I
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':, |9 T* L+ v2 R6 L
      print('ok')7 |/ M+ q  w* N6 S$ j& I
else :7 j% x, A. c" M0 q
      print('error')' k' Q  o. M% ~$ `' U2 |. {
      count+=111、写代码
" X! V( m  S4 I- f1 Ya. 使用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) :
- I0 u- J' E3 y' {  ^ if i %2 != 0 :4 S5 ~% X: s1 J$ a
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
0 |8 o7 V# c2 a if i %2 == 0:' ~4 V2 T5 g* ~) N( J
      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"
9 y, t9 x" m8 g. i& N3 Ka. 移除 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)7 `, O+ w& d& K" A+ j: ]
for i in name:0 [, k4 H2 ?: _0 J* ?
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain  t& J/ Y: E' ^7 K. k# i, C6 r9 d7 L: Z
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']" _5 R; p/ e2 w  \" D
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ' ^' M' k; k# f7 z2 Y
print(li)
& o( \" `( d2 T' I5 x+ q3 O ['alex', 'eric', 'rain', 'seven']
/ O* ]. w- S6 j! L! E+ jc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
  U7 ~' Q, ~" \4 U" E( b+ qprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')/ D$ [6 g& z: Y/ j) Y; j
print(li)
- x" z" n# J; g- ~# d/ \e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: e; l3 u8 K+ {: D+ a
li.pop(1)+ c0 d8 Y6 {( p9 W; m, ^9 A5 `, Y
print(li) ['alex', 'rain']
2 j8 h, I# v( B2 O( |' Y1 _指名道姓的删除li = ['alex', 'eric', 'rain']
* t/ a! Q$ x6 S* B# nli.remove('alex')
9 t9 J- n' @" a) Q' u2 tprint(li)
) g% P% l3 r; r# I! `1 ~f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
1 X0 V8 f* x6 U6 Mprint(li.pop(1))
1 {# x  A! [0 b0 T7 C  G; [" uprint(li)7 ]1 h3 h: e, P2 M5 p

% y) C2 I% ]; a3 a. C' i* xeric
5 Q% U" Y# ]. B" B. F, @7 y7 i; E['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# _% ]: n, i/ Udel li[1:]3 l7 `9 S8 u/ q& N1 r+ _+ Y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)( R  o( V4 R5 v" }, Y
li = ['alex', 'eric', 'rain']" @5 ]" t3 Z/ c/ Q
for k,v in enumerate(li,1):2 L' e8 X% [# X- s5 Z3 D) C" h
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ D* r4 E$ s. T' O8 g" y- P2 g
a. 请输出 “Kelly”
) C* X/ z- q* }5 kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% ]/ X0 t' ^  _9 p, M3 r- Y9 D
print(li[2][1][1])$ c4 ]% B  U  l0 R8 C8 e
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”7 j% a: {7 B* A: U1 }
li[2][2]='ALL'
  a& y$ w" u0 C! G7 U  G6 H) bprint(li)+ \7 z6 ~4 U& L6 D
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
/ m, H& H7 o$ b2 M" H+ |) ^a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
/ h6 ^8 q, d2 J; s' g; p+ Kprint(len(tu))1 E! ?7 \5 P& E: R) g) ?
b. 获取元组的第 2 个元素，并输出
4 T2 w% p% I; t+ B8 fprint(tu[1])5 E- t/ f# K" z7 r  m; B
e. 请使用 for、len、range 输出元组的索引
1 M* }  I- W. n. \7 |3 Hfor i in range(len(tu)) :
8 w* A2 E* s' k4 Q. y print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 d* h+ I# L% k# V& P; ]
for k,v in enumerate(tu,10) :3 r+ L, G  k! A! t7 I, G& u
print(k,v)6 X3 `' l4 _$ n* ~
10 alex
0 h7 M) D5 j- t) X11 eric; t6 J6 C8 t! i: Q# m3 w
12 rain/ b# k2 B. {4 w0 ~2 j
& m& i& E+ Y- J
for k in enumerate(tu,10) :, f6 Y' P+ [" L& G0 l% J- s3 B
print(k)- t, I9 X0 `) a! L; I$ D
(10, 'alex')
(11, 'eric')% g) _$ |: e. Y7 m* C
(12, 'rain')
- y% e. a& b  ]* ]6 D2 c# U5 ]
* n4 e  C0 h9 I" N- l4 `9 D% z$ h
25、有如下变量，请实现要求的功能
  m9 k( z: P+ B# C9 Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
9 F8 U- ]9 o( V& U
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
! Q" O+ F, |4 Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
5 ]% f, L6 [7 |# V" R4 zres=tu[1][2]['k2'].append('seven')! d: }2 T5 n0 n+ l% Z% m- H8 {
! I  ^/ r' ]% Y. D+ n* O+ F
print(tu). w1 G1 C# ^: f" F) x7 V; u4 Y
26、字典0 j' F" @, ]7 J' Y, q
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:# U. d* F, T* j
print(i)b. 请循环输出所有的 value5 v+ G# V: z" f3 k, j
for i in dic:
' ?  H, k! L+ _/ L) a5 W& v2 l; I* ~ print(dic)
% q/ J3 U! n! Sc. 请循环输出所有的 key 和 valuefor i in dic:
) _) ?5 e6 K8 Z. [print(i,dic)
' n3 _4 B1 x5 ^d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典) G$ t) o$ X0 w4 ^
dic['k4']='v4'
* {& Z% S0 M: b6 T# B. Y4 [print(dic)6 L# ]! ^2 F( M* I( U
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典1 s+ }. N/ h. e1 p2 \  j9 W
dic['k1']='alex'! E" v- ]/ G: T' p3 b- P0 A
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
8 b1 G4 l0 Y/ {( f, L# Z; c* Q# jdic['k3'].append(44)8 J+ D4 F6 f2 J
print(dic)8 S. O+ u2 C8 @4 b" J& F1 H: ^0 U
1 t# ?2 ]6 n# t- C
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
. R' z& a4 I( i3 @dic['k3'].insert(0,44)
) U0 Z; z, t& N; e9 o- zprint(dic)
* K  d/ d5 I) A  R4 K$ U& Z; w27、转换
5 s( b( \2 _. u7 S' ^+ r6 k  A" ~a. 将字符串 s = "alex" 转换成列表  s = "alex": e+ o9 J: ?& u4 }$ T% _" A
1 S5 m  o$ B+ a) u
print(list(s))b. 将字符串 s = "alex" 转换成元祖4 D9 }! Q7 O9 {" B
s = "alex"* Y, v4 t1 m/ f6 s
print(tuple(s))3 d' ^6 u% `" R+ X
. E1 T$ z" T, [
b. 将列表 li = ["alex", "seven"] 转换成元组. C" Y- x3 q" ~
li = ["alex", "seven"]* Z1 q, ^: T9 l1 }, _
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表' @" S( _0 V2 ^
tu = ('Alex', "seven")& c  ^6 n1 G8 E
li=list(tu)
$ @" O5 a7 C8 ]5 x5 Hprint(li)+ f+ W$ i9 f+ \2 b! x5 D
; P7 R+ Z2 ?) h4 c# _) w

0 \( O* M) j/ Y3 u* I; gd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" H9 A+ e; k) C0 t) M" p9 x

. K* {+ t$ b6 c& L. e8 mdic={}6 ?: Y( e) e& s% T' z2 f
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面- F/ k% B3 A! ?
dic[k]=v
9 t* k( v" L5 \ print(dic)27、转码n = "老男孩": ]2 n/ g5 w) M9 F& w) K4 t
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"% V6 K8 Q, ], @, [
a=n.encode('utf-8') / X/ f2 Z' ^6 A" E+ T! p
print(a)$ H& I/ y9 y7 ?5 S$ t8 w$ n, G
b=a.decode('utf-8')- q) R9 h1 h) g3 a  g
print(b)
2 m  G. ~3 c& _9 \. V# i3 ^* e/ yb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: U  ]' B6 M- h* d9 bprint(a)
. P; e1 w! ^4 R8 V% _b=a.decode('gbk')
  p% C1 [+ p8 p" vprint(b)28、求 1-100 内的所有数的和( ?" ?5 @' `* f" w# U
count=1/ F/ _( P! @0 v* j% c3 L& j8 [
sum=0
for i in range(100) :% d2 }, s/ z4 v) _* o
sum=sum+count/ L! l- h0 d+ j/ B
count+=1- C- E- ~" u0 X$ i! U- w+ G
print(sum)- F3 Z- E' L0 \

( y+ I9 d( [6 K5 t' q! U2 C; @count=10 n) @5 _) k6 o2 y2 k% Y
sum=0
# X$ X0 z3 R1 Y, iwhile count<=100 :  w- r3 |, N4 `  R
sum+=count
0 F5 w' }6 h/ X2 E6 r. m count+=1
) ~% T) Q$ z  ]: J9 _, ]print(sum)29、元素分类
8 U. y' l; [) K- m; p: m有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，6 X7 u  F' c0 C  g
将小于 66 的值保存至第二个 key 的值中。4 W( X1 y# d5 V1 X4 i
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
5 Q$ r7 X! I2 v; Xli=[11,22,33,44,55,66,77,88,99,90]
' e  N( t5 \2 x8 t( R: Q, pdic1={
" v% H9 ?0 ?# k; L1 H 'max':[],
! n& |- B+ o! l" B2 } 'min':[]
* c$ o( B6 v( V# G}
: S' N& l* l. N( Z% K  _  Ofor i in li :' {% J. L+ n) Q0 B; l
if i <66 :( K- [& P  Y3 C9 G) A7 u
      dic1['min'].append(i)
- i( p1 B  e4 `+ D- ?4 Z0 b$ A* M else:
. A6 J5 V: h% r9 V9 Q1 U, V2 M       dic1['max'].append(i)
5 R6 P/ K/ N6 K2 Z8 x9 vprint(dic1)
: o; V5 O- m& @
9 u4 |# \( ]8 Y3 u* j- A; v, \---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
& d3 Q* w5 E- h$ n' ]' c2 n

Python基础知识汇总

主题推荐