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、写代码/ d0 i9 v' a3 t
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) :5 L/ z: }" x. g3 T
name = input('name:').strip()
1 J, g4 e( R8 \% P1 W5 U( J7 ?; | pwd = input('pwd：').strip()
  K. G: `; L  U% |% Q3 v8 z- l, o3 T0 ^! w- ]5 s6 o! P( p
if name=='seven' and pwd=='123' :8 d7 b/ b; a& P2 k; u4 e7 U
      print('ok'). F7 j& r9 F  L9 J/ z
else:/ ?# v4 j& Q) S- B5 d2 i% \
      print('error')
: X: ~+ W1 [2 F$ 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)  :
. k. S  N% w( B7 S name = input('name: '); c0 r% o( K# t2 v& i. K
pwd = input('pwd: ')4 \: |' _% r5 g5 v$ X; I% A
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 C+ n3 B8 D3 f2 o/ N+ h( {6 h       print('ok')
# ?& e! p, U. g+ D2 V5 r1 d; C else :- t' C7 e- ]4 J/ B  g( m) n
      print('error')& f; L6 L( J* x% W5 @  ]5 s
      count+=111、写代码2 Q1 E2 W2 U* j
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) :
( ^) k9 b) P! e* T! |) K if i %2 != 0 :% D- c4 g/ N2 p5 y
      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 m; M* {8 Z/ Z! H/ x$ ]( E8 V if i %2 == 0:
  }0 M: s9 |$ P- M, 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"
8 G5 X$ \; b1 G9 A) R$ I& ja. 移除 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)
& ^; A# R$ l+ V" j- l, s# Lfor i in name:4 d; A! ^- K, D" X5 H% j; v! |' _* u
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
6 F0 z4 I, \* K% [: p; X: q: [; u22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']$ x" W& a" a" ?% o
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 n7 H$ M1 ]  m% \5 }/ ^% r* \3 P" C
print(li)
7 p' A8 t, y1 A$ T' Q4 R ['alex', 'eric', 'rain', 'seven']2 u# b- A7 t; U0 @( G
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 A8 i/ J) j7 R& B) o0 oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' R8 `( }* W$ J/ S  Eprint(li)
! P2 P, Q- S6 m- P; K/ V0 {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']- J2 N# U* I* ?& C2 u" ^$ M
li.pop(1)
( b- Q" `$ Z5 M( c6 xprint(li) ['alex', 'rain']
5 x5 n) V& U+ g% @! L指名道姓的删除li = ['alex', 'eric', 'rain']( m1 x4 ^# z$ i0 E% \& W5 k5 \6 w$ t
li.remove('alex')
& `, V. p3 R4 Nprint(li); S7 x# E( h1 f% j; c# j
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']( B4 M0 o( H. S; ^3 h2 A
print(li.pop(1))
% R. K( {  ]( dprint(li): X& ~: b" K$ f  w
; k) t$ z) |. f& B4 h  c- v
eric
- d' v- G4 W$ I* k7 N['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']0 N1 h9 k1 S# b' f+ k4 j$ h
del li[1:]5 V; j5 Q/ T9 U$ a0 X# P9 V# H, A9 Q0 c
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)! E: [) G1 D$ j4 M2 r( }0 ~3 I
li = ['alex', 'eric', 'rain']
+ ]" [1 s! p# j; W& _& Ufor k,v in enumerate(li,1):
& W- {1 \7 P2 `& c9 B5 ?7 J: M8 z9 _ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& h' d; R  X, S' ka. 请输出 “Kelly”
9 w- ?) x0 @$ i% a) bli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 {6 c7 k$ P3 eprint(li[2][1][1])" D1 C" h8 g; ~3 L, @4 U$ v0 k( B
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”, g, f5 q/ [$ O2 I  }
li[2][2]='ALL'+ Q' T' n, G% s
print(li)
' Q. Q; G  z& f, P, l9 k3 q24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')9 k3 }7 ?% y& `3 ?1 d3 E3 l  d  o4 f
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')  g8 _8 e( Z) t3 B/ A. I* o
print(len(tu))
% G! ^$ q  M+ v5 p+ w* tb. 获取元组的第 2 个元素，并输出
5 C4 q- ]/ l6 \  W3 h% Y) ?print(tu[1])+ H( x9 j" k3 f4 ^. {4 F0 W! f" i
e. 请使用 for、len、range 输出元组的索引
9 K/ f1 Q$ G$ X' D, a" B+ nfor i in range(len(tu)) :
: I' M6 L9 U, ~4 X print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)% L4 y4 a% T" \' J
for k,v in enumerate(tu,10) :
5 _% A. r6 w! q" z8 j. f print(k,v)
: l, i! ?: O  s/ ?5 A' ^10 alex
8 s) ^+ ?1 B" S9 t$ c7 g7 n11 eric
5 {# y8 x+ ?  n. F% y12 rain
' `9 b8 l$ E. ]% a
8 d* n7 q; F8 N1 pfor k in enumerate(tu,10) :
% j$ Z  V2 d/ |, U9 V3 v, b, T print(k)$ |& |$ s* E& n+ Y
(10, 'alex')
2 u# _8 U5 Y0 u  }(11, 'eric')1 y2 a# L! f* s, r- m
(12, 'rain')/ ^* {2 J: k" J; D9 j

$ D. Z. s7 B8 p' H  u
6 {: T, X5 R7 {. I5 R25、有如下变量，请实现要求的功能4 H( F' j+ ?% b# m9 [) H
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ h9 ?* o5 P- id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以3 ]! n) f0 t! I& d
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])9 T/ c& O0 }7 _5 ]
res=tu[1][2]['k2'].append('seven')
3 Z4 Z0 u8 ?) j0 t4 j9 i/ U2 t. ?. k3 x* D% ^% ?) K# f  W+ X& r4 z: K3 J
print(tu)
% L9 U; ?3 R) K0 w26、字典
, Z4 @; X, S# z$ y2 ydic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:3 M) B8 n5 b! Y0 R! f$ h
print(i)b. 请循环输出所有的 value
$ D5 [4 ?! {* {" c4 Dfor i in dic:
4 `: v& o  v  @/ i& F$ C& A& p print(dic)) m: p& W: `- c4 P% m6 G/ [
c. 请循环输出所有的 key 和 valuefor i in dic:" O9 q! w7 B( D5 H9 J% `
print(i,dic)# ?3 n$ @5 C# H$ g. e# [) j
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典- \- T3 G6 z+ g  f1 H* s3 x
dic['k4']='v4'
+ k; H$ G( P0 B0 M! l" T" kprint(dic)& ?" n; A  b: V) Q% h7 r) @5 C* `
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
: |% v- @+ P+ A1 H5 Ndic['k1']='alex'
, E0 d0 L- L- r6 \& \print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典; }7 O' x7 h4 p$ m8 K" y
dic['k3'].append(44)+ J& S" y5 _$ ?: ?
print(dic)
5 I2 f6 `5 s' h+ R7 b. |& Z8 i8 T& D" @/ I+ S( r  k4 W
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
" {7 ^, C4 w. `% sdic['k3'].insert(0,44)4 l8 V: m9 x* Y5 }
print(dic)& V. [  j" z7 ~  \7 @+ w5 x% x
27、转换9 @4 g; e9 O0 m' C$ Y) `
a. 将字符串 s = "alex" 转换成列表  s = "alex") ^  {  u+ T% T3 ?2 H0 k9 C

! ~2 R% n/ X+ ?  g$ u# y" ]0 \print(list(s))b. 将字符串 s = "alex" 转换成元祖8 n8 {: k6 j  I$ q- B& k
s = "alex"
% p3 C5 ]3 R. ]1 k( Nprint(tuple(s)), m5 h) m" J2 h  b+ u! j7 _

7 e$ s5 s# z7 X5 E0 fb. 将列表 li = ["alex", "seven"] 转换成元组
/ U* ?" V7 a6 M: v6 @  Zli = ["alex", "seven"]
5 C* H" c! N: P- Z6 Aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表6 \: x3 j8 l) O: i) c! {
tu = ('Alex', "seven")# w8 U- f0 c; S( [  P3 j
li=list(tu)- u7 _. \/ v1 S+ U$ Z! m
print(li)
# _3 e5 q+ b$ K9 g
5 Y: @7 @# u" i3 Y+ o9 {4 t: A8 V/ z
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增. ^( g, j( K) {4 j9 i8 a

( Y, y" H1 F! r# q$ x* ^dic={}
1 H9 w/ W6 ?9 bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面4 x2 [% z  k4 v& N9 ~  t, F
dic[k]=v
# G. U" L' n5 o% T print(dic)27、转码n = "老男孩"
( |+ y- h7 `! j/ [  Q& E2 O. Z8 ^a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"/ T/ P3 G' v7 W) d* s9 p- ?; X
a=n.encode('utf-8') 4 O& I3 P# a5 A+ {6 r
print(a)' I: P  v- Y+ `0 h2 z8 G
b=a.decode('utf-8')
) I/ D" l5 C6 p4 b( R3 G* D8 Q: Nprint(b)1 M7 V! P1 D7 F- `6 s7 x
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! e; s+ F  y3 d6 m: K6 v# N$ i* }print(a); |0 l7 i& Z, m$ V! W+ r; V
b=a.decode('gbk')$ ~! H7 S8 g  @0 ]% Y1 U
print(b)28、求 1-100 内的所有数的和$ o4 n% e- P* b& W4 g: c7 |- Q
count=1
6 U8 o3 K* e! O6 M6 y; C5 _sum=0  L7 _: T2 b1 m8 B; w  A( u1 U
for i in range(100) :
, T6 B9 u0 _/ Y& b5 {, s6 t7 v  \ sum=sum+count' b/ N8 A9 F, b( u  J4 a$ m/ v
count+=1
9 d$ f9 \! y: I% \. X# pprint(sum)) x2 v1 V4 L9 [$ e

+ l1 M" ^3 }* x' h% r0 Hcount=1
$ |. g, D, V/ G! \1 V" b3 P0 D# Csum=0
8 x+ \# r3 w, u# i! B* B! x; m% awhile count<=100 :4 c: Q1 H& \" z& X+ t2 d
sum+=count
) k2 T: e4 s3 c  D# L* K2 t0 W count+=1" ^  w5 R3 [3 I& {" q+ ?, e( ?
print(sum)29、元素分类
2 P  |2 m; @( ~0 }9 d0 k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，* Y( I0 z! K9 H  k
将小于 66 的值保存至第二个 key 的值中。5 V. ~- j1 s; E. g
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' H& K# Z! k7 y7 @5 T- A: G0 wli=[11,22,33,44,55,66,77,88,99,90]
1 x4 d5 Q2 K3 J6 H2 e/ v7 Hdic1={7 u6 v, @% d9 v( P6 J0 x6 h6 a. V; G# [
'max':[],: p5 {) Q. P  Q. \
'min':[]$ x  W5 H7 d6 f
}+ V' ]* L8 g6 B4 f9 H4 d
for i in li :
% o$ i% z& K1 o8 Z- ]/ q; l if i <66 :
0 w4 m! ]- S* z       dic1['min'].append(i)
* [, V! b; e3 V' q* K2 j& N else:
      dic1['max'].append(i)
/ j- `! s. F; k7 qprint(dic1)' x( Q  q3 @1 `2 P9 c

" |; }! P0 C( w( S/ m  U( Z/ q3 |---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}% Z4 S( u& a& T* a& ^3 b8 q- V: F

Python基础知识汇总

主题推荐