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、写代码! }) v# k9 b. `
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) :& w5 S3 q+ j" r. ]0 z6 Q" B& F
name = input('name:').strip()5 `3 T3 p! {. Y; S
pwd = input('pwd：').strip()
- @7 ~) L6 D. W- c( O
3 a$ J. ^3 `7 y if name=='seven' and pwd=='123' :
5 n9 d4 `% m3 k9 l3 w$ V       print('ok')* n( Z" G# Y3 G2 m+ q6 y- Y' E
else:% D2 Q9 o1 B' I1 s% n' S
      print('error')
  s9 S$ o, y7 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)  :/ ?& d7 S$ F! W6 i4 c9 W1 l
name = input('name: ')8 {5 A" x$ d, `( |+ u
pwd = input('pwd: ')
' j: q! |: \$ [& ^2 v% C& H5 [ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':9 s- ?: ]; |% l* y
      print('ok')% [+ \2 W/ c  u3 ~& F0 G& S
else :" U5 Q% P. E& l3 u4 s6 N% R+ M
      print('error')
  u% ?$ ^% P0 t9 G; D       count+=111、写代码
7 ?* F) N' w- Q- R1 t( G# ~% N9 S! Na. 使用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) :
- j% Y. A) Y9 I6 Z: Z& } if i %2 != 0 :& C. U' \- q+ d, F/ 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) :- z9 V9 I3 t( K- Z
if i %2 == 0:
! @. l; F& [) 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"7 A' p* Q" p3 S3 `& E- e3 }- m
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)& F8 [4 x, l& v/ Y
for i in name:
3 W% K/ W1 \8 M1 `+ G print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
; E7 }% a; Y! J" P( f% t+ I1 M22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']1 T/ q, L. a: q5 A& d
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
8 g' r5 ]  t& Uprint(li)3 y# E( ]5 R  u9 i1 u8 H5 z+ F
['alex', 'eric', 'rain', 'seven']5 }! e; g  s3 h: F: _" G7 G* x
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'): U! N; X3 }: e; R
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')5 K3 O1 P" U( K* H6 u
print(li)
. [: N3 `. N! Le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']( {1 }, h/ `& h! T/ I
li.pop(1)
( p) b! o" ?% v; j. lprint(li) ['alex', 'rain']  I1 ^) e- K& V) t, ^- Z
指名道姓的删除li = ['alex', 'eric', 'rain']
# t* L; J& B* Eli.remove('alex')
1 X: {3 \* b- l5 I0 k/ Z* e( Sprint(li): G3 p$ K% M- C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
- w( x0 S$ ^. _% u# qprint(li.pop(1))
; V# q: r4 l- X  tprint(li), ?9 D/ {7 }) e* e3 z
! O( _( [& E8 Q5 \! K
eric2 |8 T7 v3 N, p" j( m& x
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']5 X$ \, U& b" S9 Z
del li[1:]2 C% D9 G- ^* O+ h
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)) b! b- q0 T* U* L" r" s; ]$ E
li = ['alex', 'eric', 'rain']
! @' \+ z+ H; B, J# Cfor k,v in enumerate(li,1):
# x1 Z/ V) S6 W" ^7 k$ J print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 \: D/ f$ f' ]! |8 A% _
a. 请输出 “Kelly”
, @9 L1 [- k4 p8 n) X' v$ [li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ S+ \, J# R: M1 L# P
print(li[2][1][1]): k2 B* p, f6 [; g# I
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”3 z' F% L1 [' a6 O
li[2][2]='ALL'+ A# J  c. p- L6 y
print(li)- b; V' ?/ t* h+ w+ f
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- F( m# i- n3 }# G$ Ea. 计算元组长度并输出tu = ('alex', 'eric', 'rain')* }* }9 a& O9 f, C8 `7 ]9 H
print(len(tu))2 }9 k6 x, m- w
b. 获取元组的第 2 个元素，并输出
/ p. G) d* L& _3 D- b, X& L5 _  Kprint(tu[1])
/ l9 u2 z7 \% j5 u+ h$ N) Ie. 请使用 for、len、range 输出元组的索引
# [. n# Z& T9 k5 @) {# _5 c6 Xfor i in range(len(tu)) :
; R& @6 s; I: \- \9 A4 N print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- L/ X6 H5 e. P: ~6 N3 W3 ]! F8 Sfor k,v in enumerate(tu,10) :' {* \. H  ^6 F/ Q; ]) X; ], M
print(k,v)! o& ]( q% q( j. O: W
10 alex
$ U6 D6 [$ P3 l5 m' ^* Q11 eric
  I; D& x; K  {: G7 V6 O12 rain- i- \" U8 E* C

- U# ?7 k  @) \for k in enumerate(tu,10) :5 A6 g* e6 z) T& l5 n- R
print(k)9 K  T1 ]- s& a4 ?+ [4 w+ z
(10, 'alex')0 v- c4 j" r- t$ J4 F  E6 P
(11, 'eric')  U6 W5 T; C, X; z
(12, 'rain')- @  \4 `- w! ]/ b6 I6 c
4 T2 U% d& I. ]) k
0 \! P4 ]  {/ a1 K
25、有如下变量，请实现要求的功能
6 V( `' Y8 p9 N; y7 @/ i( itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
0 U, c$ V( @! o& v$ ?
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ @7 k$ t* i, L4 O5 z2 `7 G
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) G# F0 C* |% B: N+ E8 Rres=tu[1][2]['k2'].append('seven')
6 K2 G/ q5 B) a& `: v4 D% @2 n
* |3 z8 O4 a7 V9 _5 C2 M( Rprint(tu)6 s, n* A" o- o. ]7 O, R" T
26、字典. r7 U' N0 }# y
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:* ~- f( _5 `/ Y5 A
print(i)b. 请循环输出所有的 value
8 c. ^& j. C. \for i in dic:1 I' W' j1 s# }9 f
print(dic)
8 y( ^/ L7 k1 I1 x4 M8 zc. 请循环输出所有的 key 和 valuefor i in dic:
: D9 t. O0 c* z- Jprint(i,dic)
& N! f% q% m8 e; f( a: W$ P' {7 ?d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
2 z8 g. b# D/ s8 Uprint(dic)! a5 J$ x  B; Q7 @' E
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典, Y# @" s* G$ K9 j* ^1 K/ q7 ^
dic['k1']='alex'. T4 T% [8 P/ S8 j% }# {
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典% J" h7 N* g) [- O3 \7 }
dic['k3'].append(44)
+ Y" v# Q6 y+ j1 n( lprint(dic)5 y, ~1 _; A0 a) I- x, t
; n* G0 v4 a2 V# r& i: w( L
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典7 U) `' S- K0 b! B  m6 q
dic['k3'].insert(0,44)
' s5 K, m+ ?) C1 k" zprint(dic)
- s# T$ V4 c1 @, Q27、转换
9 Z9 j4 b3 e5 S  M, {, m" u5 f' ?a. 将字符串 s = "alex" 转换成列表  s = "alex"6 W6 `& S) b2 h0 }4 H' A; `2 s

; r& T+ i) P' ~& W& e" S5 qprint(list(s))b. 将字符串 s = "alex" 转换成元祖  r. i9 X5 y8 E" h* r( E
s = "alex"
" V# _. p( M. D, k5 \+ M3 Bprint(tuple(s))- |/ A' j. M+ P/ K% @' R# P6 M
, b% e: `, c+ W$ d1 h% S  Y4 u
b. 将列表 li = ["alex", "seven"] 转换成元组
$ q+ E+ Q5 }8 E7 Z9 k# z# kli = ["alex", "seven"]$ p2 p+ M9 a6 s6 |+ a
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表( K/ q4 F% [  f
tu = ('Alex', "seven")2 L* C: ]5 A% E& t% Z0 T( C
li=list(tu)
. R- R" J4 ?3 I" Y0 Jprint(li)- `$ F% B3 Q9 x! ?5 n

, Q/ Z- v$ u7 N' n4 B
6 }$ C/ @) K+ M8 a2 ~d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
; l; p! k7 n, x+ r' k4 C. |5 ?: f
dic={}! }3 q9 ]7 ]% F* z
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ {5 D, M# m* V
dic[k]=v
$ v- c  a! n/ }0 H9 Z9 n print(dic)27、转码n = "老男孩"0 \( ^* Q/ g( C4 V4 _: U- s8 }
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 p. b* T  p$ A2 f( I, m% C8 E/ Ua=n.encode('utf-8')
5 G" C* D' Z0 H& K9 Nprint(a)+ K3 L* H: w  t) _/ Z# N
b=a.decode('utf-8')" x; g  T* `; y. T$ C
print(b)
- K6 B& ]" m  n( Q/ t5 [1 _2 l8 yb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
* {$ j* z/ Q* r! t3 Y* k$ @print(a)
$ N) p% T6 g0 M$ l4 Tb=a.decode('gbk')
0 I# E3 P: C# l; _. b+ r! @) [print(b)28、求 1-100 内的所有数的和
/ w3 D2 u" j7 m9 U" tcount=1
9 z. v  y! b# P& Vsum=0" ^% G7 Y2 I/ ?/ n9 v  o
for i in range(100) :, a% K7 Z% T. i
sum=sum+count
1 o' @9 K, i  J$ N% A count+=1
4 a- I( z8 X1 f& z# ]) m$ R. bprint(sum)) C. j8 x0 v# V

4 c( f) J$ {" kcount=1
3 O! b' ?; o; e# ksum=0) c; U( @- ?! b6 x
while count<=100 :
; ~- v1 O- Z, Y' F+ l5 f sum+=count
8 k4 i. Q7 \6 l9 o count+=1* U9 t' g3 l2 a* u8 p
print(sum)29、元素分类9 c+ Z9 c4 g0 r; V9 ]) L. B3 c% B
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
/ V  S/ K, J% @8 l. X' }) {将小于 66 的值保存至第二个 key 的值中。. o( A8 K9 J- U# Q% o- \  {
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 @5 j; ~' N: G' Hli=[11,22,33,44,55,66,77,88,99,90]
9 S4 q  c' l6 l9 r) Qdic1={( \6 I" |; [3 J5 t+ u
'max':[],0 @) {- |6 e  m' u, [# j% ?
'min':[]0 g6 v: m# t5 M4 v: Q
}; ~& K8 {7 ^6 M3 F
for i in li :
# F. a8 P8 Z% Q  u# N if i <66 :
# j0 G' Z8 _8 s       dic1['min'].append(i)
9 C7 }3 e8 X; f* z+ a3 F else:
2 [; D! g4 L- @* E! E, W5 ~# f# s       dic1['max'].append(i)
! q! T/ V5 I! ^2 ~7 ]# V- xprint(dic1)
* j2 F8 x. W& J. C- |/ R0 c$ o, I+ u2 L0 R; r. D' A& v
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
: |) x' g' z4 p3 o  A$ E

Python基础知识汇总

主题推荐