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、写代码
# o( s6 y8 `& O  M3 x8 V* 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) :5 _. ^# O2 ?/ a) u/ u( a& B8 F- S
name = input('name:').strip()
& `: a  s) _6 u, M6 j pwd = input('pwd：').strip()
5 n$ [7 f. s0 o3 g& Y( D$ ]! M; A# W
if name=='seven' and pwd=='123' :
3 V# W* W  Q' ^' Y/ T1 ?# ]% l+ q       print('ok')0 p9 S, }6 e% a, b* N' V  ~
else:. ?- |0 O* Z7 L
      print('error')
: O: N* r* e) E4 R  q, t  y       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)  :
" R, r, N& a4 ]/ H# c6 K name = input('name: '): a5 n. i5 D: W! X2 y
pwd = input('pwd: ')  |6 f* F% T5 N- N0 T
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: }6 M$ h3 b/ G       print('ok')% w* o# S/ G# k% S
else :7 Y8 ]6 s6 b# e; w
      print('error')
& G5 D+ z* a2 [       count+=111、写代码4 e" W! P/ H  S: ^2 t0 o5 q
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) :' z- A8 `8 g! D  d% Z7 }% T  _8 f
if i %2 != 0 :
) B1 @* g4 K$ M; t8 V7 ]       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 s, L* r1 T' H, l if i %2 == 0:' i$ [- G2 D4 ?/ Q! s
      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"
# Y" Q4 V0 h( m# \9 ]/ W7 Q6 ha. 移除 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)( w/ A5 Y, x# q$ T3 y, Y$ C
for i in name:
0 _* s# J3 @- D" J& X9 N+ f( h( j print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
/ B7 s+ y" C& O' T, V0 t: c, Y22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  H  h% f, L+ B
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
* k: O: i# T: u6 x2 Vprint(li)1 }# l* O  s0 M1 A# F
['alex', 'eric', 'rain', 'seven']
" s+ u  C1 i$ t' Pc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')3 |' o) |$ |7 `( K! V
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')' b) Y' i3 N! c( n
print(li)
* F6 v1 w* G" r2 r0 ]9 o4 Ye. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']# p1 n+ C; u! |
li.pop(1)) G3 b6 V# ~8 ]! d9 t; F
print(li) ['alex', 'rain']3 K) M) k! }' e' V: |
指名道姓的删除li = ['alex', 'eric', 'rain']
( z6 x  C9 K; \9 b& b0 \: ~: Dli.remove('alex')
0 O; P6 o, J" z0 ^- ^3 k2 Mprint(li)+ r& t6 a7 k* G; a* j! f# K( ^3 o0 W
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']4 z3 K9 k9 h/ i( s; J: t  L$ X
print(li.pop(1))& f: |. }, t; p
print(li)
  x4 F$ i) w# c  W* X+ l
0 R( r2 P; n1 Q. O9 peric
. ^; `1 f' G, u/ s['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']+ F# F* T9 t3 c( e7 M
del li[1:]
, }# N  d, w( M  w' [print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)! [2 C3 \; l/ n, g! z3 v1 \; c5 J
li = ['alex', 'eric', 'rain']" N/ K: @% g/ A# R8 e
for k,v in enumerate(li,1):3 X9 {1 x- f5 y: U
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! p3 l3 i! ~5 W0 [1 La. 请输出 “Kelly”
4 y* W. V  L7 [/ X, O& ^li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  Z  j7 w& r. ~1 j4 V& g; iprint(li[2][1][1])
1 W9 t3 Z6 f, v0 @2 P7 T1 {b. 请使用索引找到 'all' 元素并将其修改为 “ALL”$ v" ~  y8 z0 o4 g9 E4 d# \
li[2][2]='ALL'7 F1 K5 g+ ~  W5 M6 k4 Z
print(li). S) z5 F% @) ?' ~% [0 w
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* z/ v6 y- Q- m: [a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')5 `$ W- {$ F' {& r7 J4 S6 P1 o" @
print(len(tu))7 [2 f5 ~& n  D# [
b. 获取元组的第 2 个元素，并输出
; n5 j; }2 r! W0 R# h, ~print(tu[1]): M. m$ _6 H9 c! e  k9 y( g6 s: k
e. 请使用 for、len、range 输出元组的索引) S+ m' D  m# d6 N' l- H7 e3 T3 E5 ~
for i in range(len(tu)) :" _! Y. N- [5 g7 |3 ]6 E6 G" y
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
0 [/ p, a, a9 tfor k,v in enumerate(tu,10) :
: M1 _) L" A, z7 u2 [; d  z6 c* ? print(k,v)
) a! b! r3 l0 Q8 j0 Z10 alex* h- c7 ?! N* _8 \. _/ Z% V! B
11 eric5 z* ]2 d$ \% ^; q
12 rain0 c0 M8 @- N. Y' @2 `, I

$ q  d; F8 n" Ifor k in enumerate(tu,10) :
; ~5 b4 y1 ^% f1 {# J print(k)  z! E1 i9 G4 I6 u
(10, 'alex'): A7 a9 m: \& ]' v, \  J: o7 B" `2 @
(11, 'eric')
; r! A5 i/ s9 C& D(12, 'rain')$ |8 }$ Y1 f4 @1 @, ]* m3 O! E

) o' S7 w$ c9 t9 [1 O8 U4 R, d0 r; @; f1 _/ Z$ b% ~! W. a
25、有如下变量，请实现要求的功能
& x  G% l8 {+ [! ^  ^tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
2 {/ a  V. F, }: W
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
4 x4 I5 `$ p. w, a( ]) etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  C- G* S+ D: h8 {9 L- |0 kres=tu[1][2]['k2'].append('seven')
0 t! G. k! Z' y' l4 u5 c2 K6 P' @/ B- J1 W7 A5 o1 P7 g
print(tu)5 j  ^7 D4 [0 p, V) a4 L7 L$ F' T
26、字典; n- M4 G$ p) u+ q
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
2 W$ E) {  c) D print(i)b. 请循环输出所有的 value/ f8 {! O0 M: `: r
for i in dic:
2 d8 R9 E8 `# J# b( F print(dic)
3 f& F7 m. M" u1 Vc. 请循环输出所有的 key 和 valuefor i in dic:7 g. ^2 u4 a( d  u) i
print(i,dic)
% Q$ q5 r2 }3 N0 ad. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 a' l3 f; m# c9 jdic['k4']='v4'' ~3 i/ Z4 o- d" B: g
print(dic)
+ C% W7 I' F: }, \" we. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
% M1 X1 J& L  o# Y# h/ u- ^7 fdic['k1']='alex'* h" V: g4 c* n: k
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
" s' P& I: i, H5 c5 \. W* V: {dic['k3'].append(44)# K. Y5 V9 {; u' L9 s4 r
print(dic); z, ?% L+ \& s

" F1 g- u8 l$ V. b# Lg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
9 f( s. t6 b5 H* h7 M( A, S' S  ?0 Hdic['k3'].insert(0,44). C0 f5 M  S! S! G3 V
print(dic)5 c  G+ X4 f  b6 Q. p- L& d
27、转换/ U' ?$ ~( ]! A  c$ ~3 k
a. 将字符串 s = "alex" 转换成列表  s = "alex"
2 s+ t6 ]) U$ @+ V8 p  p8 w6 T4 r, O& I. Y, _. f3 P* {
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 ?* A$ o) ^# x9 |# ds = "alex"
: |0 p: T& m' H+ aprint(tuple(s))
8 {. @) x5 A: W- i) q# u3 p* L7 H. `& y6 G# ~+ J! l
b. 将列表 li = ["alex", "seven"] 转换成元组
* m9 `$ B3 C2 v4 F2 k$ lli = ["alex", "seven"]
& k) c2 }3 D$ X  g- Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- M" _3 U4 i0 d* Itu = ('Alex', "seven")0 F" X6 \1 f' \+ K- A: C) i
li=list(tu)
( p; w: C& b0 s" V, eprint(li)
" q- H/ C  v* m; i- o
/ J3 ~, i& F. d2 D& }
( k/ p1 F6 e2 x. {! K2 gd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
( K1 y& e2 j% s: q6 ~$ h8 \. S
2 y  }$ ]  z* Q4 x1 {; pdic={}
) `2 I$ l& r* s' Y* C0 w! N* jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面# r: z; L8 w, s9 z2 l7 D9 l4 v2 r
dic[k]=v
, l$ g, F" N- h3 o print(dic)27、转码n = "老男孩"
" r% H3 `2 e. [% B& B, v) {a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"2 l, t& t/ a. ?% S# ?: Z
a=n.encode('utf-8')
& t* P3 F( {5 o0 _( @print(a)$ V; Q" f& v1 W. x
b=a.decode('utf-8')
, [5 G* @3 j; xprint(b)% ?: l" C) y3 v2 w, v
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
0 d. R$ ^& x% Sprint(a)" K; @5 g3 G7 q! o7 M
b=a.decode('gbk')
' N& [# L$ Q; x: X# Q7 {# R0 ~4 Iprint(b)28、求 1-100 内的所有数的和
) y7 u6 ], x( o3 `, b: R3 Hcount=1
) D1 {4 Y" C1 X+ K1 F) l4 [sum=0+ g4 f6 E6 x1 F8 B- y5 B0 |5 @
for i in range(100) :
9 I8 a8 J) x  C7 ` sum=sum+count+ q, F3 \1 I) ~. V& ^: f0 X* H
count+=1% G4 C# D+ r9 `3 c$ ?1 X  e4 W- B) f
print(sum)+ ~0 V, P. x1 n6 ?$ d* \

2 K% [" a2 y; g. c6 ]: i9 U8 o2 Scount=1
! a0 r5 N* \0 b3 X  ^sum=0
! ^+ J. v* p% n6 k" r* u& u, I) xwhile count<=100 :" _/ `$ Y5 k) [2 T* f7 g: Y
sum+=count% o1 y( v8 n1 ]9 Y+ q! v
count+=1
' d8 l* S0 O4 X: Wprint(sum)29、元素分类
% n0 w2 ^0 d5 p9 r; g7 Y2 G有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，# i. u9 F! e$ t
将小于 66 的值保存至第二个 key 的值中。
4 v7 R+ S, ]( i2 i: w5 E  \即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' h2 _" s; p/ P% I' |( ili=[11,22,33,44,55,66,77,88,99,90]9 O; O' I  X9 a0 @1 L* \9 b' c
dic1={+ s2 E7 i1 P) R+ W8 n$ P# A4 K2 v
'max':[],( m8 {, B% e1 @4 ]% h9 X& \
'min':[]% u2 M2 s" m! [2 B: \9 i4 J& ~
}
* E' ^5 @1 I/ P* ?for i in li :, X) A( |$ j4 f2 t3 l
if i <66 :6 F: E2 f8 O$ k) q
      dic1['min'].append(i)
: I/ v% j1 R! S. Q/ f1 k else:" K, V# w2 T, c  {6 M
      dic1['max'].append(i)4 ]+ F3 p! Z7 G) G, a- Q1 K& Q3 k
print(dic1), a5 M  p( ~1 v3 P
4 L; S; t2 s# d9 o  G) I
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}; v5 B9 B0 e9 }. O4 P

Python基础知识汇总

主题推荐

浏览过的版块