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、写代码
! i7 D8 F  w; `- Wa.实现用户输入用户名和密码，当用户名为 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) :& h6 B' c& p+ I, F& x; D
name = input('name:').strip()
: o& V5 \: c, J; @; j7 s* g pwd = input('pwd：').strip()
  H+ @0 Z: i# J- M8 c9 o
4 i& q% H4 T2 E. k3 V) W. f if name=='seven' and pwd=='123' :
7 @  z$ I+ ]0 X) {       print('ok')
3 u3 A+ C0 J8 }0 V* O, Y1 j else:3 S1 Y) ?2 y" M/ c, v: {/ C
      print('error')
' i* o1 s* {3 o4 O% q- d       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 D  ?3 q4 w9 O7 J9 q name = input('name: '): L9 j  t7 Z# ?) V! r
pwd = input('pwd: ')( m1 N1 }+ L; o4 |
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':2 j% d6 {, O$ M6 Z9 r" |( S7 C
      print('ok')
3 S! n6 [4 m1 O% Q1 T( M# f" Z else :' q4 _$ ?7 ^7 K& a0 }# x; P
      print('error')4 s) W! I' a6 z8 P+ @3 a/ N
      count+=111、写代码2 l( _) V2 k+ ^+ V4 v! 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) :9 z6 e) T9 K/ z9 W; K! L5 P
if i %2 != 0 :
3 Z; O" l5 }0 Q       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
' B$ w: u/ l. d" i$ K8 h  ^8 h$ H if i %2 == 0:$ C( [# B. p( [1 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"
% j# {8 g* V: e- `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)6 d' @7 I; s% D
for i in name:8 I1 `% j4 B4 T# o
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain) Q3 k$ L* i& ~% N
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  X$ B  o. \* q
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
: N3 ], @/ _( z" ?0 I1 Qprint(li)
7 E! w2 S9 l. ^8 [8 f+ l ['alex', 'eric', 'rain', 'seven']
7 s5 e. d6 J/ w) B; a1 B3 I+ d, Pc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* e4 v# U5 B. A. v, p
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, a$ i2 C% L0 A/ I+ Q5 G% q* o% {print(li)
7 n2 y. e. j# y; g+ @  h. Me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
/ S6 y+ W- n, `5 rli.pop(1)
) `& o$ U# g" r6 z  cprint(li) ['alex', 'rain']+ @4 @/ m9 X" G! [$ }4 [. ]7 X/ U2 x
指名道姓的删除li = ['alex', 'eric', 'rain']' B, T9 \1 u) ?5 F9 _5 W; H
li.remove('alex')& T, L" X: B3 V
print(li)* n* y# O' X0 t5 P
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']. ?7 |  u# ^- K5 D2 B
print(li.pop(1))
% ~6 i% {" t/ S' ?" Zprint(li)
& n! v) N& {: F$ s/ \7 l3 P1 R8 I3 L/ l$ J' s
eric
# G) Z. `( o. b['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# k. G3 ~. }, B. Adel li[1:]
1 v, m6 p0 R1 V5 T4 B* Qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
5 {  E- A) `# S" B0 U2 cli = ['alex', 'eric', 'rain']% u! t" W+ W/ b  z; F
for k,v in enumerate(li,1):
7 j3 }$ m6 }4 O( e/ z& f% r( G4 c+ \ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 F- f& Z' h2 n7 i5 B$ {a. 请输出 “Kelly”
7 l2 p" \$ y, y) w& ?$ Q& Qli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 |' v3 N1 @$ p& `# p
print(li[2][1][1])
; H1 E8 @. `/ [2 _8 s% {* k9 y& `# jb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
7 J$ P# b( y2 \+ @; P* k" b8 S; yli[2][2]='ALL'
2 V- G" U0 ?" V; X# Z& H# Cprint(li)- Y" z: \: ]/ x& ]8 n& Q% q- o' Q
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')$ _5 _7 w5 _% R
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')7 a: L$ g) E; ?
print(len(tu))4 l6 O4 z- n$ i' {
b. 获取元组的第 2 个元素，并输出- {0 ^1 B) z  @  L, N7 m
print(tu[1])
' h* t7 R6 i0 He. 请使用 for、len、range 输出元组的索引7 {& c; O: H0 }7 Z! ^, [
for i in range(len(tu)) :
2 X4 t. T$ N" E2 r7 R/ m print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 v! w: N* ~5 s  C9 A! R. {for k,v in enumerate(tu,10) :% I" G7 K' M; _! Q" t
print(k,v)' P- n9 l. j, P* ?) s1 z. h: \1 `
10 alex
, X1 L& s% C* ~5 Z11 eric
% {! z. o6 p* z& x* A12 rain8 D0 i+ v3 E- Y+ g# e
, r; H% {5 K' Y& l4 U* ]/ b) l
for k in enumerate(tu,10) :
7 a1 ]1 C4 Q; N7 z& Y+ G2 h print(k)
2 |& g, K  [9 H( U+ F( Y(10, 'alex')
( I: @& t: F/ @8 |/ z6 E6 g. C(11, 'eric')( g+ L/ d' g' C, [: W) z* ~
(12, 'rain')  f3 h0 T- h3 {6 e
! A5 k6 u' `. Z4 i' K! V! ?
( Z* i0 _" r, z1 I
25、有如下变量，请实现要求的功能
" ?0 i  h& b, ^* B: Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

6 u& D1 l, Z+ X* O  `# r% Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以8 T5 w- m9 u* f9 n7 ^
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])' t% J, _: O- g9 f+ o
res=tu[1][2]['k2'].append('seven')6 Z  ~7 e" x2 ~9 Q3 {3 O- b7 g6 O! e

( C/ X' K: d7 e& e  w) Jprint(tu)
+ K/ }! h0 S  g4 I26、字典
6 I  E8 z( D: t# \  Y) Udic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 M; X' n8 R# P6 |% r print(i)b. 请循环输出所有的 value: m! C7 S' f$ p9 g% c
for i in dic:
1 v  ]( ]3 s; b# f- o0 V% { print(dic)7 C9 b% M- d  ^
c. 请循环输出所有的 key 和 valuefor i in dic:: H$ e8 L8 l- N9 R+ H% r
print(i,dic)) t2 p$ x7 ?; Q/ d+ H& y
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
# f; C$ v1 Y6 T$ `: `$ G& Q7 kdic['k4']='v4'. O# U! Y1 M% }; ?, Y2 Q
print(dic)4 }# F4 J8 L+ o$ B
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典% d7 x8 h3 W% \! O7 J! A4 H" t, n, ]
dic['k1']='alex'4 O( w: ]. I7 }# o7 }: k' `8 A5 }
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! K7 ]/ U. W. f9 [9 m. D+ gdic['k3'].append(44)7 O, I6 B, ~, U2 u; }) S
print(dic)
- y4 W% s6 v: ?% [0 Y4 R
- R6 ]5 m% O' wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典% H% B+ T" K. \) \  ]3 o9 ]
dic['k3'].insert(0,44)
' s& e  a: A5 T- i' U5 lprint(dic)
' t# K. e9 r, g* e; F: x: _8 q+ j27、转换
# q$ ~9 {0 W4 E  w4 R( s6 Fa. 将字符串 s = "alex" 转换成列表  s = "alex"
4 U7 W0 T* O) t4 ]1 I2 o  v
2 B3 T; l- ?, E  Z* Mprint(list(s))b. 将字符串 s = "alex" 转换成元祖
9 D  D( j/ F( \: U9 D4 d9 \. Hs = "alex"  @7 X/ u1 p9 [2 g9 m7 t$ n
print(tuple(s))" ]. p$ Q( o$ }
& l! |% [1 s* l! r$ [7 w2 d
b. 将列表 li = ["alex", "seven"] 转换成元组
4 y& B. I+ d- pli = ["alex", "seven"]
% P  l6 F6 C( ~/ ]print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) b1 ^5 _# l& R7 b: Otu = ('Alex', "seven")( V; o. y& K9 D) T2 V3 f8 d) M
li=list(tu)6 [' j# _# g! N0 L1 c$ m1 A0 K
print(li)
7 `* B4 h7 x0 A. U+ U! ^6 |! l, ]6 l6 w1 \: i
8 A, I6 n! G5 k
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增/ G' h" W0 p* B, p' E

7 N# O) c7 ~- V& k( m. _  p5 D# i5 Sdic={}
/ ^' L3 M' @7 g/ _. c. B- f; r0 Q' |for k,v in enumerate(li,10) :----li要放在前面，序号放在后面" R: W) x' b- i4 [
dic[k]=v' V. N- E2 j7 ]  i, ~9 c/ y
print(dic)27、转码n = "老男孩"7 z; p, [: N4 l4 l! f0 h: B' F
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
  J2 q6 [; S4 x. _* ]a=n.encode('utf-8') * ~  T8 A8 l: B+ B! |
print(a)
, C. X+ r* [* v) [* u; ub=a.decode('utf-8'); Q2 \7 ?9 P; T$ Z7 P- p$ t
print(b)
3 {. ^2 m1 `- b5 u+ Eb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
6 \% Z6 K8 G( g4 c/ Mprint(a)
2 U0 W7 g# n$ B$ fb=a.decode('gbk')
' o; l, p: n- c0 s2 x$ N8 p$ z! Fprint(b)28、求 1-100 内的所有数的和3 u& i. j4 r5 D+ Z- K) F0 X
count=1& R  u& a+ H9 E
sum=09 h: W1 P: m. [( T! {. D3 s; B! b
for i in range(100) :
; C2 S$ h' a2 S* T( D6 y sum=sum+count
( j0 p9 B& F, `, [ count+=1' r0 `; X# z3 k$ X8 K+ |
print(sum)  a% u: _& P) K  ^* O
8 ^' `- Q' X, j
count=16 k4 o4 r/ W( V& t1 @
sum=0
8 s- f$ I) v2 Fwhile count<=100 :
, e1 M7 e& s0 S* A" R) @% B sum+=count
/ D+ f. S1 \) `/ p1 {. f count+=1: q. w2 T; y; n9 v# j+ m# \  C( N
print(sum)29、元素分类0 X3 b" X; m& n# F7 B5 {3 U
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，" F% O) A' q7 I3 n4 J
将小于 66 的值保存至第二个 key 的值中。
+ a' \2 n; M+ d" y即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 E8 e5 N% W% @5 |
li=[11,22,33,44,55,66,77,88,99,90]
; T' O8 N' L- b& P7 bdic1={* Q6 R8 n0 R, o/ J
'max':[],
; A2 q! C  p4 X9 m# \ 'min':[]+ I$ M/ n# Y. e' i! g7 B
}
# h2 M& n) c  H& Wfor i in li :
* d5 b- t( k4 u# d% x0 m; q if i <66 :$ ~$ ~4 {7 u) z" K8 N# E
      dic1['min'].append(i); b1 K( e' @9 c9 m
else:
8 a2 s! C, J' K' G       dic1['max'].append(i)1 Q6 U# U" s/ n5 h! z* \
print(dic1)
  W' ?' z4 {5 n0 K0 q" M7 U
- C3 {( p1 S; S- O0 |% v1 i" R8 M% O; p---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
. h, g% z  c8 K, X1 H' C1 h0 _

Python基础知识汇总

主题推荐