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、写代码. j1 K0 D; @) O9 |' z4 N$ F7 n$ A
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) :
7 r, P3 R! [" p- D4 ?4 F9 m4 { name = input('name:').strip()! r9 \, Q' X( ~! M! S' g
pwd = input('pwd：').strip()! y& s: J1 ^. n8 x* `

# Z( q1 O* o1 N4 Q0 z if name=='seven' and pwd=='123' :+ N' W# O! W8 L* C
      print('ok')
* j4 y. g. T4 y8 n, O else:7 G+ m$ ]2 O, o9 S7 e
      print('error'); Z! n: m+ d  P2 J7 z3 N' }- 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)  :* P' ]' U: P/ ?( ^2 O
name = input('name: ')9 x% l, M4 U  N- s
pwd = input('pwd: ')" c/ @7 P- L3 @/ T- O7 K2 r, _+ x
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 P8 L  l/ h1 l9 C, P) P7 S8 {       print('ok')
& C* g8 A8 ]0 Z; Y% m1 i0 G else :
4 w1 B7 e3 I# p3 Z       print('error')
- n- j. z- H% ~: e. c* e. d       count+=111、写代码1 u% P+ m3 C5 u8 C
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) :3 i3 R; K4 x0 j' q7 p' l
if i %2 != 0 :; w- [! I. u8 {: @- S& b
      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: N- k5 e7 Z& V; P6 m if i %2 == 0:
6 y# y7 f  U2 m, |( x* q, P$ R       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"
1 K9 {( {# B8 S& w. T- t& da. 移除 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)8 m) C5 ?7 G: k, F# Z1 a
for i in name:/ g6 w& M: S3 N2 L8 ?6 I
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain/ ^0 ^0 r9 `1 c% }& C
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']( d# R& O( B5 c
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    . x  B9 }: L. H3 u, ~6 X
print(li)6 ]0 }* V3 E! u3 ~+ N* }/ O
['alex', 'eric', 'rain', 'seven']
9 W( z" [& `7 l: mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')/ @+ Q7 s/ x- m' q
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
- j1 ^& R" O( i) O# Z3 o9 \print(li)
7 t! P' x/ J1 \6 R. K! {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']! N; y: E& e3 x/ Z- @9 ?
li.pop(1)
1 {9 ~) k' B) F' ]9 o" _; aprint(li) ['alex', 'rain']3 j1 \, |! F. C
指名道姓的删除li = ['alex', 'eric', 'rain']4 j! A1 d2 p5 g! H
li.remove('alex')
1 r+ T1 u: C8 {$ \9 eprint(li): W4 d; f) V; A' y2 B& ^' a
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
  l7 l6 P% z  Q, L, iprint(li.pop(1))
$ y! f  q8 r1 m* q: y6 n, M; `. uprint(li)
2 S3 T, W& g/ ~% z
$ z" B, G: T: K. j% [. heric* `5 n, q4 G' k1 ^; y6 f
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']( U  }4 T8 A: `4 R4 L0 U) {$ H
del li[1:]9 N$ f% a; F7 K( R" i5 J, m
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
8 b$ A1 d: E2 b% Ili = ['alex', 'eric', 'rain']
2 z/ ]! M0 U; {' y( mfor k,v in enumerate(li,1):4 Z3 o9 M- R/ }* G/ C& o
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  V7 e$ U1 s' U; M! h7 B2 Ua. 请输出 “Kelly”$ |$ }) _. a( `) d2 N
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]- _( M4 B( P* f( E
print(li[2][1][1])
7 \1 P; M& i6 b: G, Db. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, H+ k2 l& x5 N- L/ y- Wli[2][2]='ALL'
% L( Z$ t2 Z$ O% e: x% F7 Xprint(li)
+ }+ T, w8 d% I* C, R/ I" t24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')1 f4 O9 l! M2 z4 y4 p
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')) R' K! h2 [+ `+ S, G- S" K
print(len(tu))
& M! P( _- T8 k/ j+ X6 B1 vb. 获取元组的第 2 个元素，并输出
/ {- y! s0 |/ l7 l2 wprint(tu[1])" h  e! L& d5 F5 Y7 U
e. 请使用 for、len、range 输出元组的索引
" v# M, a9 l, Y5 @7 l0 K+ [for i in range(len(tu)) :' I! u7 M/ |: G8 j7 \
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)6 o* V; j. g9 G5 V
for k,v in enumerate(tu,10) :& C3 `' d8 ?: p, N
print(k,v)
; q+ M- G8 I6 q% o! [10 alex
& e% Z3 S" N) w: @$ B11 eric* T2 b% F( ?# ^8 \, m
12 rain
$ n% B/ w- h5 U& S  ^! P  C5 w2 X. s, H& J# h, B! G: q
for k in enumerate(tu,10) :
2 e/ V) G# l' p, @1 |# K print(k)
. c, U( ~8 D1 u! |(10, 'alex')
8 W3 b" k* y$ v# x& v3 H(11, 'eric')
1 U2 f/ T5 j5 l; E& d% v3 e) M(12, 'rain')
  b: q8 B, l$ I6 S* N/ K. s/ h$ i* D4 M& R4 Z. Y
# r$ j9 O- h8 x$ \; U. A( s
25、有如下变量，请实现要求的功能* ?) q# \9 y* X( \2 L. W
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; o( t' K* M* k& o  ?; @1 Jd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 ^1 i! g& y5 |+ g2 b( _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
" }& e+ ~3 {8 T7 jres=tu[1][2]['k2'].append('seven')& v9 s0 \+ K. \- E

: a, w+ n- d. h. v6 Fprint(tu)6 N$ t1 c' C+ F5 g- {# n. O- ^
26、字典6 ^8 [% y2 w7 H4 H6 u- D, @
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:. ~/ h5 ~7 i5 \0 E1 p) y
print(i)b. 请循环输出所有的 value# o+ d0 v/ W; k6 \
for i in dic:# n2 W3 V: T5 V
print(dic)6 f  h. @7 G8 w! |0 n% U; K( |/ R  c
c. 请循环输出所有的 key 和 valuefor i in dic:0 c/ O7 n4 C/ y5 |6 E( B+ H4 L8 m
print(i,dic)
& Y4 S& o: m, E2 l6 N1 G8 Hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典5 M/ p# U) r. B- g2 `
dic['k4']='v4'
print(dic)
3 A6 Z" O8 c9 }) w4 W7 ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典6 {8 p5 V' C$ a, ?9 d
dic['k1']='alex'% W7 T2 x4 R& ]3 r
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典4 v0 t, D% }4 ^/ {
dic['k3'].append(44)
5 z8 c/ y: z/ \5 bprint(dic)
0 i, s' x: m2 H! S5 h# Z
0 S+ b9 l/ R0 M0 I. C; F/ U$ qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典- S2 |) R5 K& d, q) z7 v9 K
dic['k3'].insert(0,44)
( n$ Z2 }# T7 k, M9 |! Mprint(dic)
5 C0 J- v; u! x# r4 g9 t: t27、转换; U- Y, b* q7 L& V- d$ @
a. 将字符串 s = "alex" 转换成列表  s = "alex"- Z) m7 ~  T# _* i' b2 q
0 F& ?7 n) e# Y$ }$ q0 s8 j
print(list(s))b. 将字符串 s = "alex" 转换成元祖! u5 V9 K, F' a) A" h# j
s = "alex"
9 y5 r. V* r% @- C# X5 Y6 V* _, k% pprint(tuple(s))# N8 S) u8 N$ S. o& W+ ]

9 G7 u) N* x0 W+ f* g  I; rb. 将列表 li = ["alex", "seven"] 转换成元组
/ L4 q( K4 D5 K! ali = ["alex", "seven"]
* }9 \# g; K4 J9 n% Pprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表8 ~' y5 Y: B: x) J" ^5 P6 r
tu = ('Alex', "seven")3 ?4 O9 ^% J! z$ V0 P
li=list(tu)
* Y$ g2 q: o# Z- }5 hprint(li)
8 J" h4 p$ f, e
* ^3 X) W! K2 C( G
6 x% J- l# T( b  q7 f& U( Sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
; Z1 Z+ j; I( }; h% q" k6 g! K% H* x% ~# Q: Q0 j' j2 }0 @' r& y
dic={}
" J' g. h0 U7 @for k,v in enumerate(li,10) :----li要放在前面，序号放在后面  ^% J+ F. B& @
dic[k]=v
0 ?( x+ m: B9 j5 O9 D# I" l' r3 a print(dic)27、转码n = "老男孩"9 ^1 X8 T' J- g3 a6 w: C6 w
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"& _7 E6 Z9 f; G+ i
a=n.encode('utf-8')
/ }$ B; x' W* ~7 N$ @4 \0 fprint(a)* ~% t$ q7 D" L7 I* d0 d* C$ M. |1 o
b=a.decode('utf-8')
, w& e4 q8 z7 K* P1 j* Q2 w( nprint(b)
; C  `- ~% \% r2 C8 rb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')+ i0 d6 y" w3 S5 q2 v7 \
print(a)
4 v$ ~# ?, a: m4 D: `4 n& Ub=a.decode('gbk')
$ g. f  ]! k4 O5 s( R- `4 T3 `+ Rprint(b)28、求 1-100 内的所有数的和
2 R) B: z; ~9 ccount=1. C/ I: m& R! C' i, K% V
sum=0
/ o$ v" _6 g6 M* p& l) Efor i in range(100) :4 o3 r' `1 O' b# _4 w
sum=sum+count
# J4 _' X/ g0 E% @& t$ l* f count+=1$ z& Z6 L5 k# @$ E6 Y8 Y
print(sum)
$ z' r- f" U: j9 v( d. m. i/ F/ ?% f! _! W! s
count=1% v  w. q2 q6 }! ]" W# e
sum=0. N9 b6 b3 d$ `( `- y: v2 [7 y
while count<=100 :
9 F* {  X3 z4 L: v9 y4 ?7 K sum+=count
0 M" {( o* |( c8 s, r: w count+=1
  ^* y  f! f' a3 X1 bprint(sum)29、元素分类' s0 x5 e, n: _/ s& }, a! \
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，# G! z# q; Q& B
将小于 66 的值保存至第二个 key 的值中。) k8 @) _2 N4 z! Y6 c9 K
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 Z) U/ {! {6 \li=[11,22,33,44,55,66,77,88,99,90]/ x9 I7 Y2 y0 {
dic1={  l" R# [5 j% m3 s$ T# f
'max':[],
2 W. O: N- W, I9 x9 H; L2 R 'min':[]
. D9 n4 \! o9 V+ ^# e}9 _0 q( ?: ?/ c' r3 C' P
for i in li :2 V* u; z0 v. p: `# N
if i <66 :' @. f) i% W" j4 C2 S
      dic1['min'].append(i), f. e# b' I5 Z
else:# H: q: b4 S  _7 Y0 S
      dic1['max'].append(i)' [+ o" ?0 Y# U' d0 ~
print(dic1)
) T0 [2 M& }) x& X9 j- v6 W" g2 n) f& t& c
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}  G( O! @& t5 t5 g# I

Python基础知识汇总

主题推荐