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、写代码2 ^0 i/ D7 e$ l6 F# K" p9 L& h5 R
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) :
0 O8 n& e7 l. t# l( ^$ t  p) t name = input('name:').strip()
- @# M2 f! L/ O$ q& Y# n pwd = input('pwd：').strip()
5 ~7 ]8 M- ^+ F7 T/ [
* m5 C( ^; J$ p/ j) R' V4 r* ]. T1 Z if name=='seven' and pwd=='123' :$ ?) {* q9 j7 k9 k  d' |- C, p1 l4 f
      print('ok')1 w+ b# T* B4 x. R% Z. r
else:! t1 Z5 ~# s4 ?: e, j: v/ F
      print('error')
! d" M/ Z7 U' W- E       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; ~. h# _6 [; k8 y; ^
name = input('name: ')
$ D/ |$ B$ e6 ~& \. s, k/ P# B5 h pwd = input('pwd: ')% r( o* t, h* z& Y# d, a
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 a9 Q. P6 g- m% R  ]       print('ok')0 ]' ~, E( \7 e$ O) x
else :2 [- @4 z  F! \3 G
      print('error')0 B$ T7 M# i/ s4 Q# f( t* e
      count+=111、写代码% y9 N5 U% \" C1 ~0 L
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) :$ ^, F0 g/ @: d
if i %2 != 0 :
& @% G& y: K1 e$ M  G6 H: P       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* `3 w% g/ X% D& L if i %2 == 0:0 `; H# I( L# @- _
      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"4 Q' y5 h+ [4 G7 X& x
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); a% Q9 h' B$ J7 O( {) a( a+ o
for i in name:
+ m3 O; `2 @: S4 E! o, C print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 d4 z/ g, G7 b+ }$ _% j! c
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
) \" Y  z! S- }* u' t* B7 Vprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 W' S3 s  @- m; _print(li)
) `; ^) ?0 j5 S; J7 o( F  z/ Z ['alex', 'eric', 'rain', 'seven']
9 D6 V; _+ N: y2 ?; U. X- |- J1 ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
/ A. w1 L% C- Z# k, lprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
; r- z2 S0 A; B. |  s0 i: `- ?print(li)- |. k% P9 R5 H. Y, N0 C( ~3 @
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
+ A* n9 s* O% M& gli.pop(1): P1 P3 Q9 C) s0 L) P6 a
print(li) ['alex', 'rain']
" B4 O! g; s1 ?, B) E. E. N9 b* Y0 ~指名道姓的删除li = ['alex', 'eric', 'rain']
4 q% w7 }6 T4 i  eli.remove('alex')
! c2 {9 a  A* _print(li)
9 c/ f4 F, }: i( L5 ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']; @- ]# z# H8 m
print(li.pop(1))' s% e# _  ~) [' x/ ]
print(li)
! L9 a8 ?1 g3 x- @
' A& O# P; f' X) o; X. \' Leric4 o! Y$ e! H. P9 l( X
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']6 e/ l& ~# `3 C; u1 x6 c
del li[1:]5 ]+ {" n+ e9 f" `
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
5 o& c' M; [/ k8 {0 pli = ['alex', 'eric', 'rain']
1 [7 Q' x" Y. w9 D" ?4 Pfor k,v in enumerate(li,1):- ^% s# Y' m/ p( K- Z$ ^
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 C8 Z+ m+ a: {" Y# U" b/ L% f& @: aa. 请输出 “Kelly”
5 F+ `2 J3 d. ]! c! }li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 I  ]( ?# `0 m3 x+ ^, N9 v
print(li[2][1][1])! |* [, r6 k# t" w( s
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& {! P6 ~/ ]# E' t; xli[2][2]='ALL'
( i" X' H- }: t+ q) a) D# Dprint(li)' w, k; e; ?/ P4 Q3 \2 Q3 N
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! X6 W' z0 E  c! \4 Oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')# S, q9 T  h) j5 Y) V
print(len(tu))- v2 B4 `1 w* Z7 E/ D( i. n* x5 g
b. 获取元组的第 2 个元素，并输出: g" G' q/ c5 W1 W0 g- D
print(tu[1])
, q- |* x: {" U& ^. R0 O# Xe. 请使用 for、len、range 输出元组的索引, R' u9 ^! r. |
for i in range(len(tu)) :! A8 e( P3 ^, u  l& c3 `
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, m  i5 ~' X  Z7 e- l) ~for k,v in enumerate(tu,10) :8 f; B4 |% _8 {8 ?
print(k,v)
, E4 c+ n" f6 J: ]) R10 alex& H# K- {0 E" v& Y
11 eric
& }# b9 a- E/ X: J12 rain. L; V/ e' t- i" B5 n3 j8 u

# d% s) Q+ X3 afor k in enumerate(tu,10) :
! ~, w- W; g6 W! {6 u3 e8 B( a5 D2 } print(k)+ m  t; e. M/ p) i! x) I# v: {' V4 W
(10, 'alex')4 ?7 ]! N' d) F% @- j) V
(11, 'eric')
8 v6 r3 ~  ~4 C* ]! ~: y(12, 'rain')
( c; `, z1 }, [" b+ V
( [: v: D8 H8 t8 E4 F  {# X, O9 l, X1 j+ c1 m) c5 E( K
25、有如下变量，请实现要求的功能* _, I2 O. k/ W7 A- ?0 F! J8 i- b
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

9 Q5 d: ?; [* E) u" K7 `# ud. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
/ u# w3 ^5 @2 c/ H; rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
5 W7 l% `5 k8 A# t0 s; H5 A  ]res=tu[1][2]['k2'].append('seven')
4 d! @( m# h  b: h) r6 n, w% e& p4 x6 X+ \" y2 [$ Z
print(tu); z2 A2 N4 N6 e. J; s! c
26、字典  E1 h/ m. l: _. p- Q0 U& D
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
/ @- P  n. n1 s" G& r6 U' g# m  b print(i)b. 请循环输出所有的 value. S, o/ V! G5 e, n, Y
for i in dic:
: H3 ?2 K# e) u: O; J3 E0 @ print(dic)* B- R/ z9 p- F) {( }
c. 请循环输出所有的 key 和 valuefor i in dic:
! `9 K! H0 Z  A, f& b7 O. Hprint(i,dic)
; m$ G! ~7 q' O1 I# h! x: Pd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 |9 i) b7 @% U' ^dic['k4']='v4'
& U1 p/ G& u: Q7 V$ O2 \7 r7 r2 fprint(dic)2 x2 @  s# }4 E* i' v7 z! h. N
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
8 e; k! ?5 K! qdic['k1']='alex'
. p# s: c% w6 o4 q! ]" T$ Fprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& l% z* `: Z$ m8 g( I6 M8 k" \dic['k3'].append(44)! o' s) Q1 a# _0 K* {
print(dic)4 T. K# q7 {$ y

+ O- r% u! O" \# Bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' F7 n+ t, K) l7 M& udic['k3'].insert(0,44)/ d; [# j  G2 t% x; K& F4 i6 [
print(dic)4 y$ h% h$ b( A  K4 c2 q, }- C
27、转换
  i) m5 X$ F9 V/ K+ ]! ja. 将字符串 s = "alex" 转换成列表  s = "alex"+ l3 o0 |7 @6 Y2 P4 w5 D. u
8 O' V6 V0 t# \: d- z) R7 e9 b
print(list(s))b. 将字符串 s = "alex" 转换成元祖
% M- T0 l4 O$ J% g) us = "alex"
, \5 C0 C- L9 S5 Z, o) d  Rprint(tuple(s))
7 _! X* b4 R5 S/ G) M# d0 r
. [7 P- N' z8 Z. [; Q) }b. 将列表 li = ["alex", "seven"] 转换成元组
) _9 @+ m- F0 C/ D: Q3 ^9 Mli = ["alex", "seven"]# q& `  @. H6 u. e# V7 i' |
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
# A- N4 t" w, t% Rtu = ('Alex', "seven"): l/ d; x% t3 A0 B5 m6 T
li=list(tu): U( F" p9 y8 M, y" m+ P. B
print(li)
9 ?" a$ {6 w! X8 h& L# W5 r' G" R& c  U, z  @
3 ]5 l$ E# j5 i" e$ U
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
3 ~; q( K, C9 o
+ S% n. L8 r# f! ddic={}& q, q9 r( O6 [5 K- W/ k" `# x3 v
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面7 L. s" P7 D1 f
dic[k]=v( w; u7 ?2 `* R3 C0 W* _, m5 Y- U( j
print(dic)27、转码n = "老男孩"
! h, L% p# ]) @# }% q: U9 j7 }7 U6 ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. g9 i  S7 e0 X9 z7 ~a=n.encode('utf-8')
; x1 u* Q) L! q! A0 t# {' uprint(a)5 ~8 `" S& F% ]) m0 B
b=a.decode('utf-8')! n. c  j8 U0 P1 [. E/ G
print(b)4 {% U0 |/ w5 q% \( r
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')2 C' X5 d% @- H; A2 j$ a2 e+ S6 F
print(a)
* l* |' W" c- _; ab=a.decode('gbk')& D5 G2 V0 M5 _4 h* U
print(b)28、求 1-100 内的所有数的和) Y5 y. J1 k% p4 n% [$ [
count=1
, t6 k# x. p+ }6 _sum=0
2 P' {4 f* P- a" H" J# bfor i in range(100) :
  R/ e/ k$ Y# n/ {) x8 G" y, s sum=sum+count9 v( p4 `* J: ?% ~" p7 _5 D, A
count+=1
- P3 i7 M& ~, d6 b' nprint(sum)
' X2 D: {- x2 X/ J, T! c) L! j4 n& d
count=1
/ G" ]# \5 M2 [sum=0
) i  C; `4 p8 Z. jwhile count<=100 :# Q$ ?, M* P9 h* X2 Q
sum+=count
" e1 |1 T9 _3 g count+=1: @# c/ l2 L- S) g
print(sum)29、元素分类! {# X4 c& Z, Q! L  w8 v$ o
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, M% J- p0 _% J$ R将小于 66 的值保存至第二个 key 的值中。
3 _9 {! f" i5 u1 p- w% |, Y即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}6 @: S; W/ W: R
li=[11,22,33,44,55,66,77,88,99,90]
0 _' S* D( c* [7 t# Adic1={
: y0 h. s6 C& _ 'max':[],
, m3 O% q& r/ E5 r( u/ Y0 x 'min':[]' f% }0 W4 U# E0 _/ ]8 F
}
3 C9 p: ?/ x& M+ X2 b' C2 ?( bfor i in li :
: ^) a: F0 i+ t7 P! G2 i  k if i <66 :! M- B# ^2 U2 I6 ^* P
      dic1['min'].append(i). E1 M! r$ X# s/ L1 T
else:% {) T' @. v9 |$ _. y
      dic1['max'].append(i)4 V  B# e: C* v0 s$ u
print(dic1)7 R* ]8 T8 p& u# }  C

9 T9 r6 c& B* _! j---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}3 t5 H* G- [- ?8 F' `! W

Python基础知识汇总

主题推荐