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、写代码: M7 n; E9 \; f- O' o0 ^
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 ^3 \& g8 x: g7 U
name = input('name:').strip()
2 {8 E; b- r, h pwd = input('pwd：').strip()! v7 y* Y/ q! [' j) E" {1 a

: G( V& m( h2 B: ` if name=='seven' and pwd=='123' :
7 Y( g; B2 m' O( G  r# u       print('ok')
3 g$ ?9 M) _) _3 E3 E else:
% S  ~2 h# @: v! M/ y" `       print('error')
: {* D* w& a9 s9 V4 b; 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)  :
/ y9 q1 Y' k0 e( H4 n6 E name = input('name: ')7 V  s) S7 j; F- x( j
pwd = input('pwd: ')
2 {4 K: V* D  v! A3 e% N7 s if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( A( V6 s* U: l       print('ok')
3 N' i% k: v% t7 \+ | else :) W+ E) I& o# o
      print('error')% b" K4 ?/ w. Z' y
      count+=111、写代码
/ |0 Y4 P; j- y" x% Ha. 使用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) :# {5 h$ q& L" n( H. I1 Y, t
if i %2 != 0 :0 ]) S' e* J, e
      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 t% T  _- j1 [, C; M, d& k2 j if i %2 == 0:
8 c- ~1 k, ]! @2 C       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"
* h, \2 B0 f3 ua. 移除 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)2 P! u, D% x7 O, q( u$ a
for i in name:
+ M3 R4 _! [8 N print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain$ t' W" v; \" f
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
: N' g. ]& b& e) {9 P, @( eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
3 }, x$ p8 Y( I  N# L- d5 }print(li)1 h/ _/ Y- [  b5 \* g% N
['alex', 'eric', 'rain', 'seven']
8 K4 \7 j. L6 r" ic. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( {% a* x; N: N
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
8 E% y4 l3 o# Y6 Y: }* nprint(li)& W/ s' {" D# S  U' j
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
% z7 X) e, w$ c9 v# k& F; Nli.pop(1)5 _* ]* m8 n5 q+ f& {% Q2 w" s
print(li) ['alex', 'rain']
+ F% s7 e" s9 M! ^) M/ m指名道姓的删除li = ['alex', 'eric', 'rain']
) c- P1 v6 Y* {% X/ F* dli.remove('alex')
1 T. T  B5 _) C( a4 y$ ^3 xprint(li)3 n6 H- R. i& K
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']- H9 w* O  Z# F! |" l
print(li.pop(1))
1 `5 M( g2 ?; W. u* N. eprint(li): x( h  J5 Z+ b1 i4 w
& Z& o' z/ K6 I5 d
eric9 x" p1 w% K9 J
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
' M0 y5 N0 Q% Gdel li[1:]+ A6 @3 W/ s1 ]: L  _1 ]+ V% P
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)! G# H% ^) I* Q6 B# b6 a
li = ['alex', 'eric', 'rain']
4 r* ]& j4 o$ [( }" ufor k,v in enumerate(li,1):0 g+ `+ m" O9 d3 L* L" d
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% E/ A/ O/ N# j' G+ ]a. 请输出 “Kelly”5 j3 M; [: s* q  x' b" K
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% X1 A  [5 b7 w1 J
print(li[2][1][1]). u2 H; _# r% S5 i8 a5 U( R1 r( X
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ d. b0 j; d& N; lli[2][2]='ALL'( o) X5 N. t$ Z9 m& P+ E
print(li)
) b2 F' p' z- a8 l* }24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
/ U+ @+ F6 V  la. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 D7 Z/ {  d# `& ?6 hprint(len(tu))
b. 获取元组的第 2 个元素，并输出
2 w; K( d) a3 aprint(tu[1])
/ C9 L) u  C+ m7 x2 e: i& a$ Q  [e. 请使用 for、len、range 输出元组的索引) l8 {9 z( ~9 d0 U
for i in range(len(tu)) :
4 |) N: @* J. g, X7 \) o: Z0 [, S0 G print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
; j! f9 O; M) n& l1 Z' B2 \/ Gfor k,v in enumerate(tu,10) :' X! U6 v# I/ L5 s- B4 ]
print(k,v)! O& N  `$ p$ E3 v
10 alex
  K: g: _# O5 C11 eric
, o+ a# U2 v; U  X+ [! C12 rain$ X" U% X& _; D3 b4 X, }. y6 b

; k) T7 [7 H/ C+ s# t3 gfor k in enumerate(tu,10) :% @' D/ S, }3 ?* k
print(k)( G3 d2 I# w& t0 I  c* A. F
(10, 'alex'). m( N0 E! I9 }# Z& T
(11, 'eric')! r4 Z( r$ {1 `6 r% n
(12, 'rain')
$ B: g6 n) e8 I
6 ^/ z) Z) s9 W6 k, L- u
- I* E- x2 D6 b25、有如下变量，请实现要求的功能8 u' Z+ R- a. |1 z
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
4 U4 R# B9 ~: ^2 |1 D, m
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以) T0 \9 E4 y/ J9 E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])" l2 m  {0 T$ l4 P9 {
res=tu[1][2]['k2'].append('seven')) r5 D0 F) M! u" K# Z/ \" L. Q

0 j* z. L% f9 f% D/ l5 Q6 hprint(tu)
, M1 p! t; d1 d9 C+ u+ o26、字典
( j! v4 X4 L( k* Udic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; u: W" q7 |- s/ U/ s print(i)b. 请循环输出所有的 value
6 I- h* R/ D, m- N; L- |$ s3 |% {for i in dic:7 c9 y) a& ^5 z! n
print(dic)
7 {* A5 T6 B3 j% }6 Vc. 请循环输出所有的 key 和 valuefor i in dic:
4 w/ l" T: ~, y4 ~( Lprint(i,dic)
3 [7 c5 ?: }  p9 H7 b- Rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# n; Y' c/ y- N# e5 k
dic['k4']='v4', J* r. ~8 E# M
print(dic)3 V( F* |* w" i& z7 m
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
: [, I4 X6 r" wdic['k1']='alex'
2 j; b9 P' `' p& b! wprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典" r. |+ w# u/ J5 ^
dic['k3'].append(44)
; n1 ~& ^. b7 x4 n( Pprint(dic)
3 ]$ _# `. U" s$ i
; p9 n7 ?; q9 X* `5 `2 x# Mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& S6 g: u0 [5 Y- Q* D1 jdic['k3'].insert(0,44)/ M! \; Y9 [. W9 d. W
print(dic)
# L' i6 Z! Y( s4 ]/ d& W27、转换
" C! y2 i: `- h) o7 ~; da. 将字符串 s = "alex" 转换成列表  s = "alex"3 A7 E3 M  ?$ y9 G$ @, L' \

3 ]. K# H9 X+ L' l$ u7 h+ @print(list(s))b. 将字符串 s = "alex" 转换成元祖* Y" H$ s7 [7 s5 X2 V: F1 Q
s = "alex"
- R+ b1 E3 h: n% ~6 L" ?6 Hprint(tuple(s))6 K% X* G' ?+ A/ J, f

8 G, x% z" J8 m( ]! fb. 将列表 li = ["alex", "seven"] 转换成元组
. F5 o5 u# ?7 G1 b  L: T, Wli = ["alex", "seven"]6 j" `% \+ c) H1 B
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) o7 O- z# @% ]# v- j8 v3 }tu = ('Alex', "seven")) u7 |# j$ O* U! H9 z9 z8 v  ^6 o  L
li=list(tu)
3 m9 v% ?- N/ d% H! D' i" Uprint(li)7 a  `" {4 S7 {( w) ~2 H/ v# O- K

9 P5 n3 f, f# [( \6 x2 E5 e- X  [# `! n/ B) O
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
$ i* {. ^4 W( e9 f0 a4 k1 V: U# Q% k- i1 c5 x# k# M
dic={}' m1 R" l' T- v: v2 _0 g* O
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面( W2 ]1 B: ]8 X6 J. T( e7 a
dic[k]=v& ^0 o5 ]9 G4 ^- e
print(dic)27、转码n = "老男孩"; ^. `7 c. O0 }% |$ q. W' |
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
2 V. q" Z' Z; }8 I* E' Y7 m3 q4 Ya=n.encode('utf-8') 7 {5 v! Z/ h$ ?1 S/ [2 u$ [* @
print(a)
" ?- W- O- B( X$ M! T; Fb=a.decode('utf-8')
2 t( u9 ~* v  \) h0 Xprint(b)
# d$ B. q. c7 bb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! s5 m0 x: u, o- Pprint(a)8 d4 p$ Z) I; U6 I' [- R& L
b=a.decode('gbk')
" g: c1 Z% O4 {print(b)28、求 1-100 内的所有数的和
1 w) x# F9 L3 s5 F4 Zcount=1# x% l$ d* b0 U8 l! D8 Y' Z' q
sum=05 t$ v2 `  t4 |" P; a4 ^
for i in range(100) :1 p5 P% j/ x( u* }
sum=sum+count
4 u$ `6 Q2 M; V count+=1
2 z3 S6 K! ]0 Uprint(sum)& K$ Q7 Y; D) C4 c1 v

. U4 C- o3 y! L' n/ |* Pcount=1
6 }# J5 r* ^7 ?3 U4 P. Qsum=0
. V. l$ O) x  K" u# wwhile count<=100 :
4 m" z. Y5 U4 }( m4 t& [ sum+=count
; s& |5 v, d4 p0 i3 }5 G count+=1+ O' {. K; \' N# g# t/ G- V: D
print(sum)29、元素分类4 K  s. D/ X4 W
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
) ~% j/ Y! q& K' I1 b' e4 J将小于 66 的值保存至第二个 key 的值中。
4 x: ~& b$ A; K3 O即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  ~% a& s% T( j2 `. Mli=[11,22,33,44,55,66,77,88,99,90]
1 K/ W3 U- e) }5 kdic1={
4 j) f2 Z- U' T5 ]2 ]+ ^ 'max':[],
2 u- t3 V! ^! `: f% t+ o 'min':[]! h  q) q1 |6 u& ^4 d$ ?& t) _
}8 `: @; f/ R7 L5 H! n% t
for i in li :
! l3 B2 Z3 E5 H% F if i <66 :9 v* ]" X/ A4 ?# T2 O; S7 K! f
      dic1['min'].append(i)
$ h2 d0 D& w2 w6 a' ^ else:7 Z7 Q1 @. {8 |$ B4 U* Z
      dic1['max'].append(i)
( I$ d  N/ \0 V9 `" _print(dic1)" h+ D5 b2 r: I9 F
! j9 D8 c3 `) |. N* }- w
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
% _* d9 Z3 D! U8 z# |) g

Python基础知识汇总

主题推荐

浏览过的版块