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、写代码
- R; ]9 I6 `5 X0 V% H& ~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 p+ J, f4 A# y- w+ p. f+ _3 [; D
name = input('name:').strip()
0 A. p3 v) R( @! S* E9 R3 ` pwd = input('pwd：').strip()1 C8 ?- O# v: H& J( \
- V# ]! B) f1 O
if name=='seven' and pwd=='123' :% J$ Z3 H2 l& K6 k& P, p# D
      print('ok'). B; @: d4 @5 J' _2 q4 }0 A0 n
else:2 q' ^8 L& g0 G
      print('error')7 l8 `5 I' \4 ?& ?; ?: X. j6 Z
      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)  :
* z" j4 A" U4 d$ g) l  e7 p( Q7 f- n name = input('name: '), i+ x9 r2 c  s
pwd = input('pwd: ')
9 ~0 a) q3 {( y+ d* O% N if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 N5 n7 W# Z" i. I) H& m$ e* g       print('ok'), M( n  |. F. Z0 h* _+ D7 T
else :5 {4 s' H) k% v3 I  |4 v
      print('error')
; h! T' U) V) U' s& }       count+=111、写代码
/ e* X* |  Q2 p# f: Ta. 使用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 E, @8 `9 j/ V/ @: B4 k) k if i %2 != 0 :
) e0 a  [8 Y- v5 _       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :; i3 J# `% l7 L3 b4 g
if i %2 == 0:
1 U$ q4 o* y* s; d8 z8 @$ 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"
  Q( N# a2 w: P$ n. Pa. 移除 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)! v( E  O" w0 W9 v: O
for i in name:
( @/ k6 I# c( t( }) r* W print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
0 [8 X4 b* F4 P. [3 z' b) Q8 w22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']. K" b9 Z' c* m: q. Q  W
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 j$ }" w& A5 p& p8 Y+ ?print(li)& L! ]5 l( h/ K* ~
['alex', 'eric', 'rain', 'seven']% X; d  ^% }' B' A9 w1 s+ B
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- O/ B) L; O$ o; g# W5 O/ l! dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')/ I5 Z  {0 ?$ c, W' G
print(li)
. k* y8 _+ {- g& c& i) X$ Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']8 [8 g* N( _& z) q: L2 P
li.pop(1)
* ]7 K  A5 T5 E& m6 cprint(li) ['alex', 'rain']8 d3 X! J: {' M2 U, D
指名道姓的删除li = ['alex', 'eric', 'rain']
# g# c! l- ^0 q) F/ l: Ali.remove('alex')- |- G! z7 ^4 \) V
print(li)
7 U" n' ?# l  I5 d3 ?f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ k) U4 ]! ~" D3 ~print(li.pop(1))
0 e* [" b8 ^) Y3 ]print(li)
0 y8 e7 d' b4 P+ q( K- p7 Q* D, c& V0 ^$ N! z8 j
eric
5 y, u, p# _6 i9 d8 B['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
+ I1 M. b2 p7 V1 e" bdel li[1:]7 T6 \0 z+ Y/ f9 v5 a  \, W1 x
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
$ }: Z9 x; T4 ~4 Dli = ['alex', 'eric', 'rain']. a6 u' k3 Q8 B1 B' B! c& y# \
for k,v in enumerate(li,1):, K5 ]) A" r/ @' y' r' u
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& k5 |; }. J: e9 U- y' g
a. 请输出 “Kelly”; J/ Y0 R3 R4 a! M& N
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 J2 {; c% X6 k
print(li[2][1][1])$ q8 _; o1 [! j# R* h
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 j  d! _. [8 \* }5 B$ M9 |( c" zli[2][2]='ALL'  E* ~6 f* D" R' }) X, ^( ^
print(li)5 i9 A, o4 j8 X9 X9 F/ g
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# l* l' q" f% T8 ka. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
7 J; p8 W5 I! S" n% r; N, j3 eprint(len(tu))
b. 获取元组的第 2 个元素，并输出2 O* s# x: }7 h& H
print(tu[1])
  r% n" I- J2 m: u) y' |6 Ge. 请使用 for、len、range 输出元组的索引
0 ~% |4 |" f* kfor i in range(len(tu)) :! n6 `" n- B# b
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始), x5 o. Q) N- r& N9 b3 F
for k,v in enumerate(tu,10) :. Q  R) I$ c2 s
print(k,v)
/ V8 @8 t- d3 h* y0 t4 H  ~, M10 alex
3 d' [) ?4 q3 W. r! P! S# \11 eric  z0 y( n; G. L( [" W$ b4 A/ Z- i
12 rain$ v) D% |/ `$ }
4 }3 t" c/ o; E8 h
for k in enumerate(tu,10) :; g  X  T) Y7 v
print(k)7 i2 n. }3 Q* \
(10, 'alex')
7 I" a, q9 y. p* r2 g( s(11, 'eric')0 }6 Y/ L* M7 e, A2 F
(12, 'rain')
% d) M  K) S, h0 Q5 S" B
0 R6 y% ~1 a/ }9 m
# X7 p; B& t7 S- N25、有如下变量，请实现要求的功能2 e4 u0 N! U/ S0 ?- a
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
6 o" n  c0 T1 o) l
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: u7 k* p5 ]  ~: J* r+ ?+ Ftu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ M7 ^6 s8 Z0 q, R9 Yres=tu[1][2]['k2'].append('seven')
9 `8 e; d- O/ V" S- r+ P" b' _' I+ L+ i6 o+ N5 H* E$ O
print(tu)
7 N2 l! x* w; \1 p  I26、字典- E5 [( s5 q, o0 v. F
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:$ q2 g/ e4 j" r" y
print(i)b. 请循环输出所有的 value% H# ^1 T% B# v  s* H9 Y- e3 |
for i in dic:
" R, m1 w* y+ e/ |9 T/ \7 X; M7 v print(dic)
& O. r3 u  b& {# J2 J& rc. 请循环输出所有的 key 和 valuefor i in dic:6 l6 F+ x, c% `0 w8 f
print(i,dic)( H  c3 f, b; O) J7 E$ s4 o! B  m# Y
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 a: ~: v0 W; @2 c# H0 c0 V1 I7 w5 ~dic['k4']='v4'
! t1 r( y1 T9 ^, cprint(dic): N; G. M$ N+ e' T: A: X3 k
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 {5 j0 p4 s0 F8 \
dic['k1']='alex'
& i9 r1 \5 i# H$ ]+ Gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典6 G8 i, D- o9 x/ f
dic['k3'].append(44)) e! Z) M5 C) i/ Q2 z
print(dic)* w! f% s! ~- J: O0 s+ ~0 c) Z

8 S/ Y) A) h- `g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典. ~) ?; u, m+ |8 d; i' T5 Z
dic['k3'].insert(0,44)
2 S0 F) M' r7 Y+ i+ |' K/ Lprint(dic)! z; H( l) l2 E; R, o5 X& r6 j
27、转换5 M* l1 ?: D" G! s: k7 W
a. 将字符串 s = "alex" 转换成列表  s = "alex"- e& s! j  H9 v. \8 Z3 `# q, ^

4 Q8 R3 ^7 m% A9 {- x5 n* S% Nprint(list(s))b. 将字符串 s = "alex" 转换成元祖
' Y; f# ]9 p0 M2 ^s = "alex"
! s8 x* {! s5 |print(tuple(s)); }/ }  ?% P. ?+ _
- ]5 E( ~9 q2 p4 s/ f7 T& p
b. 将列表 li = ["alex", "seven"] 转换成元组2 `- y, N" c* |2 C6 l1 k
li = ["alex", "seven"]4 D2 g$ N# d* a) N
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
& p5 a  d" U) ztu = ('Alex', "seven")# l% Z; k. ~& c6 o7 ^
li=list(tu)
2 g  _. J' |0 v* B' ^$ ]/ B" j+ S% Mprint(li)0 _4 |% y+ d* V& k
5 u6 `2 q% `  ^' f% k, q, {0 o' T

/ O: L# ]" [; o* N: Ld. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增. [" F6 x1 f& b( f8 T& A

8 W* ?' u9 n3 x$ y3 z$ M$ vdic={}, w& O$ V) S4 u7 ~1 f
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: [( o' X) k: b dic[k]=v
2 v+ Z, i5 H2 U: B7 { print(dic)27、转码n = "老男孩"
' ^2 \# C% i% l0 s9 ]* T% A5 v# [a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"1 w. J; `% ~* m& s8 Y
a=n.encode('utf-8')
1 r8 T1 q/ L0 ^* A5 _7 W) lprint(a)
- I3 s. f$ i' J! a! J& ub=a.decode('utf-8')
8 l9 T1 i" i7 pprint(b)
& R$ c, W2 z; l5 Cb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')- v- L0 F4 T! P" j5 R
print(a)
3 c. u/ Y: n& ~* \! ?* tb=a.decode('gbk')
% I" y3 D, X+ y! x( o) ?print(b)28、求 1-100 内的所有数的和2 Y4 {/ t9 C! S" E* u0 }' @
count=1. P6 L; o5 A1 k) `, w1 Z& s* L
sum=0
7 O( L& l% q- Z! rfor i in range(100) :& _; j" Z9 c: i* v! M3 r
sum=sum+count
$ J2 h7 S+ e' y1 H$ P count+=1
# |: E4 }/ ?. [& Mprint(sum)
8 G8 A( V( h( m) J: r% S0 B% e2 |. i. z" `2 y: Z8 `
count=18 l( R" S: _+ y% c- d+ s/ ^% X
sum=04 o) R: d8 C# y# B5 a
while count<=100 :* O+ U3 r/ }" I3 J9 O# J
sum+=count
, w* l% [, R; B; |" Y) Q& Y3 G( b count+=1
- Q8 R5 x. R8 L) U0 s% \  q( z( ~print(sum)29、元素分类
5 P* j6 G- v' S8 U; U  C; v0 h有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，% W+ z/ W# g* V9 F
将小于 66 的值保存至第二个 key 的值中。
- @' i% V/ d. y即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
8 p& N. i4 o  Q8 n' Nli=[11,22,33,44,55,66,77,88,99,90]) o* f- h8 J1 c2 I1 \; Q2 g
dic1={! k" c! d$ k& [) Q1 M2 \
'max':[],0 O5 R* x# v4 _# v* r
'min':[]$ u4 K( E4 E  W/ H% V/ G
}
, Y2 ]4 X9 q- N+ Nfor i in li :2 [0 ?! S# B5 V" x/ \, i
if i <66 :
3 c8 H, ^9 l# @8 c; W# W# A0 n       dic1['min'].append(i)
6 ]* z+ h: c. w8 H else:
# Q! J: V( E+ Z6 n1 e9 y       dic1['max'].append(i)0 C& K+ t3 E+ h5 F5 [( ~6 P
print(dic1)
, \1 @# i1 ^' R6 Z3 M1 \
* m) B  E% C' F1 p---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}% _. F% g2 V6 ?' F0 h- |' k

Python基础知识汇总

主题推荐