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、写代码6 E0 R0 j- z5 Z. z" a* f
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) :2 ~# \  |* H4 B( B. s4 b) i, ~
name = input('name:').strip()# m# I; T8 f, [, a; Z1 ?
pwd = input('pwd：').strip()
$ b* Q2 S+ I: d" y  G
( Y1 W: e2 W- _7 C1 m3 I+ F if name=='seven' and pwd=='123' :
8 G5 ?6 S, S1 [( r       print('ok')& V; y+ F& ]+ o$ T
else:. H, y' p( a3 m' g
      print('error')
& |( t4 s2 v7 b, V9 i, w& O       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)  :4 A- z+ ^! m8 _: N% U1 @
name = input('name: ')
  {8 b) d- x7 E! r. U! a1 A pwd = input('pwd: ')/ Q/ k/ w  l8 a/ v3 n; x  w& D
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':; ?4 a' q+ S, h4 T+ t( N5 r3 K& p
      print('ok'); ~4 G& I4 a6 {7 w
else :
$ W1 c3 _1 V( w       print('error')
9 {3 H# H8 Q* \; ~  v       count+=111、写代码
$ J( v. t1 e3 F, m0 A+ I2 Za. 使用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) :
$ j3 W! H$ _/ F" X+ j# e/ B if i %2 != 0 :
' ~, C3 _7 O. `- `7 ]3 M       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 A, q3 `5 |6 j3 ^1 ?
if i %2 == 0:7 c  e, y: o4 B7 U
      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"
& P7 e, I# B. r+ R6 ~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)5 y! ]1 v. h/ ^( y; X
for i in name:
% A1 m" f& M# w& g8 D3 P print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 c- w9 r- J  ~: b( Y  L
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']9 f% _/ q; J; `1 r. C2 N' f/ k
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
' Z, d) {, Q+ M) kprint(li)7 [: L0 {! K, \
['alex', 'eric', 'rain', 'seven']3 t1 W; j  y4 A/ q: ]
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 c. A" X" Q3 qprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" K& N# R+ ]3 |, I2 Yprint(li)
/ `. I6 M# Z# I# Q" P3 Ge. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" Q  E$ ~! I- y& V3 ^9 `, Nli.pop(1)6 X' t) t7 T% l) v8 z7 ^. U3 O% |
print(li) ['alex', 'rain']+ _+ T7 a5 r2 ^' E& x: R# ]) f: s
指名道姓的删除li = ['alex', 'eric', 'rain']0 C. t' [' ?" Y8 q& O
li.remove('alex')4 p, A0 z# _, [: Z0 t
print(li)0 x/ P- L6 m" j
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']1 p0 w: R) D/ Z- e8 `) v: z$ K; ^+ Q
print(li.pop(1))
3 ~( ^4 B: K. m( F+ zprint(li)2 V6 z5 \& T$ p8 B- }3 L
$ U* R: R9 M: u, }" a
eric" b- b7 e) ?) C  c; k' y/ `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) |3 ]( L" z( U& k! x4 _* z3 }del li[1:]
) g# F& S: |8 J0 h# S; o9 @" dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
- X$ T' J/ O5 Eli = ['alex', 'eric', 'rain']
) Z. t9 y) v1 j, \for k,v in enumerate(li,1):
+ v: v; ~7 a- |( @ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 h) e: u+ w) v6 }a. 请输出 “Kelly”
8 j* s- v# l8 b" W; }8 [li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ w2 h0 _' e7 b+ i8 _6 M1 A3 hprint(li[2][1][1])
: c9 Z0 `5 r5 b$ L4 _b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
5 l4 s2 u) h' Q/ ~, }7 b, Z* |li[2][2]='ALL'
1 s* p( d5 E5 a3 t) r" @print(li)/ z! ^; e5 _) M1 t
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
1 j3 s" J9 ]* \0 S5 t9 y, va. 计算元组长度并输出tu = ('alex', 'eric', 'rain')4 B% A% `7 S$ M; G/ A( y/ {
print(len(tu))
  U# Z8 ~7 R' ^b. 获取元组的第 2 个元素，并输出
! E0 U; x2 }7 M9 r3 rprint(tu[1])
: O! F; {% p3 q& O# Z6 oe. 请使用 for、len、range 输出元组的索引
# ]% u4 l+ a/ k: B5 c$ l( ~4 N) Ifor i in range(len(tu)) :
. n% G1 R& l; v  Z print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# P2 e+ [9 g) Tfor k,v in enumerate(tu,10) :: P$ S+ l; F2 }! G
print(k,v)' E- e/ g7 W+ U# [( I9 `& _7 H7 I2 N
10 alex
4 s4 H6 O) C7 \11 eric
8 m5 Y# ^& F( O; T- z) l3 H12 rain7 s6 b+ q# N' U1 i
3 d: X/ o8 }& Q  y- A% W2 R& S
for k in enumerate(tu,10) :2 b. F- m( @; S7 v9 y% W) q8 R
print(k)
6 K3 P* m) w' y: C! H3 S% O1 W' v(10, 'alex'), J. p) h+ m) j( F: O% P( |
(11, 'eric'), k9 p# F% q8 M+ e# h0 X8 n
(12, 'rain')) P1 p" H$ R7 N
% V3 e: B9 B* W# @  y) m
7 p2 l# `9 I! u) t/ U
25、有如下变量，请实现要求的功能9 ^2 Q2 d0 ^) h7 r8 @
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

# ^$ ^$ Y: x! g) r+ x: ?, \d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 H* r' K) r3 K4 J1 Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])! k8 ^; \; |8 U8 E/ n+ J( x9 Z" x
res=tu[1][2]['k2'].append('seven'): K9 t; ]5 W, s2 k; v5 |+ m

, X# q# @; o* m1 Kprint(tu)1 N' k7 J1 a1 {& a$ F; [& h
26、字典
+ p: W9 n! ]  G$ M: X/ y4 j( adic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:7 D9 Z+ V3 c9 [
print(i)b. 请循环输出所有的 value
' b  s) I2 K) R6 J# Tfor i in dic:
# `% {! ?: |2 x" z: O print(dic)
: ?/ Q+ \) c: ?( b& ac. 请循环输出所有的 key 和 valuefor i in dic:; s3 Z7 n$ \% Z
print(i,dic)
; w7 S/ Q! k0 q9 I- Bd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典' Y5 M: K3 |: J% M0 M
dic['k4']='v4'
# r, l& ]+ R% n. i+ P9 Dprint(dic)
# s) J# S* i' De. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典" @. U! g; s0 X7 k. Y. C6 K" G7 _* q( [% i
dic['k1']='alex'( Q; r' ^, h; k- G( V
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典% v+ t$ O2 W* m9 h7 W
dic['k3'].append(44)7 ]) y& j8 h/ N4 y& a% Q
print(dic)8 x: _  K7 \( N/ W) Z& \
/ e2 ^- v3 s/ h
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典. O( h# l, T7 U- [/ l8 u; p
dic['k3'].insert(0,44)( {! k3 Y4 ^. E$ Y. l- e" r
print(dic)
- M% h$ ?% i/ @2 m5 [27、转换
) Q7 I* J7 r2 i: e: Ha. 将字符串 s = "alex" 转换成列表  s = "alex"* u6 I' l3 g9 d  e% l1 e
8 x& Q1 W; f) e; S
print(list(s))b. 将字符串 s = "alex" 转换成元祖# ]; C7 Z8 v$ N; I& M" |/ C
s = "alex"
- N7 w- ~/ g. R+ oprint(tuple(s))
1 q5 H! y3 X6 d1 v, _& Q7 Q% ]
7 g7 q# U  I& t- eb. 将列表 li = ["alex", "seven"] 转换成元组3 w: ]  [% v+ C# W
li = ["alex", "seven"]7 D3 f9 K8 \8 d# A1 v% X
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
" ~' G7 T' N7 e! j5 e  |tu = ('Alex', "seven")
- H# o3 v: o9 O  x1 n3 qli=list(tu)
) }7 ?" O: O' h/ I; Nprint(li)3 O  }" n- l! w% h
' K' d; H# r2 k! j8 [
! _' Z  Q% h7 M% J0 r- l. _
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增$ X9 v# u/ |: R' W* j6 m9 J6 J, P! b
% v( p+ i0 }2 d, e6 Q- O
dic={}
6 m( S9 d. a5 F6 P5 J7 h0 ofor k,v in enumerate(li,10) :----li要放在前面，序号放在后面5 j1 q& v; d8 k8 I- n3 n4 ]
dic[k]=v/ |4 K' S, {$ m) ~
print(dic)27、转码n = "老男孩"1 S7 V( H8 W6 e( P  ]) n
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
- M) y2 \! f2 Q$ e+ xa=n.encode('utf-8')
8 Z7 n' O$ H4 b! S* kprint(a)
! r/ h$ P0 `: G! c. wb=a.decode('utf-8')
+ P; R- u2 C4 E" x- x! jprint(b)1 @9 l2 h; X/ d
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 y% _5 @$ c! {' b+ |/ [print(a)
( n2 Z9 F# M7 Gb=a.decode('gbk'). N) m7 l0 I" C2 a" m1 N7 C
print(b)28、求 1-100 内的所有数的和
% s8 r6 B& i: C2 h: bcount=1
0 _9 i0 e# ]0 x8 nsum=00 k- r/ Z4 o$ ~: q. j4 V4 _, u
for i in range(100) :2 x4 w& {  r3 S* v  K- r  a& z/ o
sum=sum+count
1 Y: r5 c$ q% _ count+=1
5 v* Q5 N4 _8 @6 uprint(sum)5 O( L# W- O, t+ `, L) g/ b

/ j! B7 W9 k8 {7 q' Q4 S' xcount=1
2 z, h- ?! c8 ]/ dsum=0
( W0 G' e+ G  |5 U  xwhile count<=100 :1 ~  R) x- l8 e  {0 O. g/ C: G
sum+=count
- ~  i, c  b- k6 K5 j+ f. G count+=18 N* u3 G1 Z4 A4 P( r
print(sum)29、元素分类0 l- h0 F; F1 B9 O# w. x' M
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
# s, X4 K, @5 {, |1 c5 w将小于 66 的值保存至第二个 key 的值中。3 S7 v$ G9 [6 s1 @6 }! E
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
, M  f( |* `7 kli=[11,22,33,44,55,66,77,88,99,90]0 G! l8 L" L/ |6 n% y2 b
dic1={
3 J! p8 Z1 o6 z  ~ 'max':[],
7 W* b# t, n6 W; S$ g4 ^& `( k 'min':[]
5 O3 M% Y2 C6 L}
7 T% y( s! g" n1 ~3 R" I2 B! Hfor i in li :) t, B$ S* L5 S$ r8 n; i
if i <66 :
6 J: i. p6 S4 I& G       dic1['min'].append(i)
1 j; `% o4 S% |  }" S5 Y) \. j# s else:2 W/ |7 e  _8 _1 j
      dic1['max'].append(i)
& b( R0 A- Q0 iprint(dic1)$ c# I, D( F% X- e

, @  l$ z; z5 X  P+ Y0 i---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
. e6 S' s6 |6 G) J) N- ]

Python基础知识汇总

主题推荐