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、写代码
2 y/ L& l) u- H! o, w/ M# Aa.实现用户输入用户名和密码，当用户名为 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) :( o. s. h% T& O. w9 D
name = input('name:').strip()
7 T* R# @1 m& @, x& p pwd = input('pwd：').strip()
6 ~, I" Z/ Z" V6 Z+ F
0 V5 Q' L: c4 O4 p' i  g# r- N$ C/ x if name=='seven' and pwd=='123' :, q7 ?" {* _. g& t6 ^/ D
      print('ok')% k- ~& Q2 Q) Y9 j/ x  @5 ]) D* ?8 k3 j
else:
. x! L. k; Q/ ]; }- r2 E       print('error')
8 Y6 \* B7 v. K# b- p! ]       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)  :& s5 ]( W. N5 @
name = input('name: ')
- ]; {$ x. o$ X pwd = input('pwd: ')( w, n8 B# `: O! V$ T; {# h
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
4 l+ j8 a, ~' x/ ?* ]' e. z       print('ok')
" u9 Q& A) \2 [3 v else :7 ]+ u- m: i. d& h& o5 u
      print('error')
# M5 [% i* `# q1 R2 g& d( ^       count+=111、写代码* O9 h4 \$ Y+ P; r0 T
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) :" H3 F' n2 z9 a: q) Q
if i %2 != 0 :5 Z1 s' C4 c0 f3 u3 [  x
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :' |$ \2 T, s8 N* v" @3 [  X0 [
if i %2 == 0:
) J4 b* q# G; |9 O4 U8 j, k/ C, {       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"
" F# B& o4 g# x9 e7 D, }$ b, @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)% D; e/ Y1 y4 q' H! K
for i in name:; o) X% D1 ~6 P. F" G: b
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
2 Y9 P5 W' n+ v2 Q/ D22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']' C) _! ~( J6 T  A
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
/ W9 f/ V7 ]$ u) Z" I1 v& Eprint(li)0 b6 n- D3 i: Q. b. _! z  Y
['alex', 'eric', 'rain', 'seven']+ @1 i: E) q7 g/ ]
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')  d7 R+ `4 Y/ u; Y
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
) g" z/ d0 m- `" H- M5 kprint(li)
; K' B4 P! X5 u% b7 ae. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']$ H, j/ s3 b( q# d3 }
li.pop(1)5 x; ]9 U3 ?+ G4 e. _0 [' t$ l
print(li) ['alex', 'rain']8 P/ ]. j- Q7 P, d* a! a0 s, S
指名道姓的删除li = ['alex', 'eric', 'rain']
8 l, Q! T) B; S7 d$ Tli.remove('alex')2 |, B# m0 Z7 ?; c8 B$ t
print(li)
9 H1 N% Z7 ?- i% a2 M! O& m$ Df. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']' `, ^4 p1 o" m6 a3 R' a
print(li.pop(1))
/ K3 v8 P, A8 f* e0 X3 }print(li)
( u$ Q: B& R. t& S. _5 \1 l4 c% u
3 {% B& y/ `  f  W2 s. feric5 x) L1 J* H; X, b4 a' N! j
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']+ ?+ K% w% @% |/ I0 @
del li[1:]) d6 K% B! K! K9 H: h! o: M( V, Y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
* ]* J" t0 O- Q( {' }. H9 E% Uli = ['alex', 'eric', 'rain']' s2 r+ e4 L; @. h
for k,v in enumerate(li,1):
- W% w/ f, v/ V- W3 w print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; O, v5 Z* a: D, C, \a. 请输出 “Kelly”+ c9 J' n" Y4 u. P2 p' @
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 _0 M# h1 E' G% k% X9 X
print(li[2][1][1])
1 _' X" R' L9 ~5 \6 [b. 请使用索引找到 'all' 元素并将其修改为 “ALL”# P, D: B& z* \8 Y$ [
li[2][2]='ALL'
- H6 F3 z( T( K2 X+ b, mprint(li)7 K+ z1 p. G% p6 Z
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')% f. |4 k) p+ L! f4 _! Y
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; @4 _& i4 ]9 `print(len(tu))$ q  |' P- x% z0 Y/ [$ f
b. 获取元组的第 2 个元素，并输出
* I/ K+ J! b) j: g, a7 Yprint(tu[1])1 J8 W0 V# g! m0 N7 I/ U
e. 请使用 for、len、range 输出元组的索引
$ @' s% y  [) D7 w# ifor i in range(len(tu)) :( p! ?6 L* k9 H1 g8 s
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)" |/ X$ ]( }* P: f, t& Y: o
for k,v in enumerate(tu,10) :, b* u) ?( Q9 r* E8 s- i
print(k,v)
9 U5 \9 K6 g. \% O: w10 alex8 g1 ?! t" d: F3 `3 ^1 Q0 A
11 eric* `5 N: f$ ?: k; r0 g! ]" G) ^- X
12 rain9 m, ^# v3 M! u* `3 G
2 z& w7 o# j; `7 F. j% F
for k in enumerate(tu,10) :/ o8 D+ Q# w' f) n4 Q- A+ f# j
print(k)0 i/ ~' r3 d( K- _, b8 }( T2 I
(10, 'alex')
" u6 P! e6 G, ]! c  u# l(11, 'eric')
8 ]5 ~  G! M+ e7 v$ G1 a- w(12, 'rain')
% X, l" y/ `3 ^1 V2 R  F
& ?& E7 h! w$ z: q
8 ~, [3 r# w! q9 W, ^2 Y, L$ W25、有如下变量，请实现要求的功能) L8 T2 N  _4 B' v( o' P
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
/ o. G0 u# S- ^' i) h
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
* r% F4 m6 z" v1 ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
$ k# D% K9 p9 @& D: o; j2 Bres=tu[1][2]['k2'].append('seven')
5 [" K% ?. \) K; m& j2 F/ K; b- ^8 k3 ]+ C! |
print(tu)
# H5 J9 d+ z& |* @, D$ [26、字典; \- g" m' X5 _
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:+ \' F: B9 G' @9 D1 m" U
print(i)b. 请循环输出所有的 value
+ X7 M+ A, Y( N# j8 Dfor i in dic:
/ O' T7 m/ G! { print(dic)! ^3 t8 V' w" ~9 N6 J
c. 请循环输出所有的 key 和 valuefor i in dic:
9 b2 ~6 Z4 T* U& O: ]print(i,dic)9 f* f% V: O- H, C$ Q9 o- Z# E
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ S! O$ Y% Y8 h6 G2 fdic['k4']='v4'
% `. ]+ f! X5 \" j+ Iprint(dic)
$ x6 h$ `$ J# f8 H1 E7 ue. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) Y8 q- p- {8 [; J# Z, ]dic['k1']='alex'
: f7 t  p' |- Vprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
- p. D3 L( _$ L  N9 G! jdic['k3'].append(44)( F) B6 ]$ q. h. S! \' z
print(dic)
- B" O4 @- k& `# d/ S, B! X. R( o- Y  J, w3 M& ]
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
7 L, f) {" ^" A3 x( i. Udic['k3'].insert(0,44)6 k3 n) B& k* y7 T. j0 o% ]3 m3 t
print(dic)# I6 J$ G$ c& n9 k1 Y5 `1 a% Q
27、转换
& L' M4 ^  v" X2 c+ u3 b; C8 l0 ~a. 将字符串 s = "alex" 转换成列表  s = "alex"
7 y8 o4 r, e- q9 ~7 K
! e& t% n- E' I) n8 Yprint(list(s))b. 将字符串 s = "alex" 转换成元祖. H: C' {; j* n5 B" C1 e
s = "alex"
: B" Y) v+ X3 o9 W7 @4 w! ]print(tuple(s))1 p8 K3 b! H1 ^, A$ J4 l) Q5 ~3 ]$ ~# T

. Y) \0 D4 s& I+ nb. 将列表 li = ["alex", "seven"] 转换成元组
& ]# j6 _% N' J- _! J4 A; n1 @li = ["alex", "seven"]$ N  E! V- d) W
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
4 I$ U0 A2 }0 F) c7 K+ w: |tu = ('Alex', "seven")5 w, I" C  [0 ]
li=list(tu), ?& k# E/ {# p+ r( W; \! A
print(li)& R) z# q$ S$ L
% P" i; r+ |9 f. |4 X& R5 T4 L7 ~
  F6 S/ m  Y6 T9 b( U# D
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增& a+ J" b: a' K' k
5 V/ z7 O* }" V) D  g" d
dic={}" N% w% W0 j( \" ~$ [! ?
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 @5 u. g7 t& r2 b. _9 A1 W dic[k]=v
0 L- Q2 ?: e. _3 v print(dic)27、转码n = "老男孩"
5 R/ {7 y% ]! }+ ga. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# a& W' g, s: x0 g# {a=n.encode('utf-8')
, K6 L* A; L7 V( f7 Mprint(a)
% ~, H5 S" |( T4 Yb=a.decode('utf-8')
( K8 u0 a0 r5 }/ C) m% Rprint(b)
/ m- c; b! P: J9 V) x; V  @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) ?  j! K7 R4 V* H% nprint(a), d0 L# d  l; h8 y; A
b=a.decode('gbk')
& y4 X. j! N" ?. S5 o5 T8 x/ F3 Jprint(b)28、求 1-100 内的所有数的和
6 \+ Z3 ^- J; `) i/ ccount=1
  u6 `5 y6 V8 d" f% q1 i1 Wsum=0! s* T- p# A) k7 v5 }
for i in range(100) :! u( j/ h! F* h* `+ S/ s; J* q
sum=sum+count! o, Z+ H! g* g" P: S2 k2 I) a$ J
count+=17 f( @: V3 W8 O; B
print(sum)
; M/ F9 d8 O$ ]; z5 m; ]& i9 Q
( }5 }7 R# P9 T: f# {count=1
" M" u2 ~  Y' Z2 Psum=0: q3 [+ V" V4 ?$ w8 N, B9 {
while count<=100 :- @! r' R' F' H% Q) T9 }
sum+=count
1 E3 b" i0 k8 e+ H+ V; X% g; V- a count+=1/ S( v* h" g% y$ ^, f
print(sum)29、元素分类
( ~7 x4 f( ~. F+ }! f有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，# Y2 ~! \/ E0 J) Y4 D
将小于 66 的值保存至第二个 key 的值中。& k% K3 T- W- J( \
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
" Z1 H2 s7 L, i% U, V, z1 {li=[11,22,33,44,55,66,77,88,99,90]3 l' U8 e6 p& m7 k1 i
dic1={- i9 p& l& M8 X3 z+ c
'max':[],
5 l* v! g2 _7 {. c: _$ Y4 ]) |# t 'min':[]
4 M' r6 ]9 v1 Y& m" R" C9 f  F6 X}0 H1 I. A, P$ f, b% |4 O
for i in li :
3 x+ p  \! c* _: g0 I2 J if i <66 :' V% Y5 v# s! m. t  f/ i5 n. R
      dic1['min'].append(i)
2 I3 t! Y( P3 ?) `- Z/ ^3 ~9 \ else:. Q" [) a' f& @1 `( F# T6 D
      dic1['max'].append(i)
# E2 T& K/ E5 V; E# G) [: tprint(dic1)4 ?9 j# C! n( i/ v
3 O  Q, V! q& h' k4 _+ Q
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 P+ P# `0 [3 A/ z; [

Python基础知识汇总

主题推荐