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、写代码3 T" _. r  q- D; g1 \- r$ v
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) :; Q3 l1 ?/ o8 q6 v7 X
name = input('name:').strip()
- @" \2 ]9 }( Y$ X% A) b9 ]. H pwd = input('pwd：').strip()& r3 o# ^( N7 `8 R( K. d) h

6 H0 r" g1 K) [2 w3 @7 \ if name=='seven' and pwd=='123' :, b3 j" \7 j3 v" z7 n
      print('ok')
2 l& P# R, _5 f! |. A2 L4 x' ^ else:
# ^$ G$ y* R# w       print('error')
% {$ z5 n/ a  m8 l; E  s3 a       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 E9 R! q7 Y, [- \$ [ name = input('name: ')
8 @# F  e, D+ h' ^& K0 L1 h2 U pwd = input('pwd: ')& s2 H" a3 Q/ S8 w2 V7 i
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( K+ y/ i$ u4 ^8 B* a       print('ok')
$ S  m( i4 a2 P) r* `+ z$ ]* ^9 g$ o else :
- |  c& F- U& X$ N       print('error')
6 [2 `- ]0 U/ ^+ G2 o       count+=111、写代码  c& r- K- F0 p) O* q2 t7 O4 g7 C
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) :
% k4 h2 ?- a2 ]/ K$ N/ Z# U if i %2 != 0 :
, c! `8 H( q, ^1 s       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! N& o6 g  s4 o if i %2 == 0:
* o# M9 [* h' r5 ]& |4 v       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"0 h' C0 V) x4 J! O( A: @
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)
/ p0 ?- s( V0 c7 g- z) Afor i in name:
" j) W; F9 T- Z% ~3 z8 } print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain3 y, r9 b! {. N4 G
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- [2 X* s5 g* e1 d* p. ^- K1 ^print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 m1 P3 e8 i- b6 W8 A
print(li). \0 Q0 ?' r8 V" N% e) r
['alex', 'eric', 'rain', 'seven']
* f/ o' E1 D& z  Q) Fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'), M4 v8 `: s' \: v7 t
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')- v- l! t8 |  A
print(li)$ N8 p% u5 T6 f# q: Z2 N8 O+ ^2 k4 u
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
5 c9 W1 }3 Q/ @& Sli.pop(1)3 M1 x1 U% W$ G4 i
print(li) ['alex', 'rain']
# {7 ^, t: I1 j指名道姓的删除li = ['alex', 'eric', 'rain']9 V0 j3 D& @; I5 x  K$ [) U& t* N
li.remove('alex')
8 V0 c& h2 I4 D+ d( p$ `print(li)
( Y! k7 O2 z  w2 \9 G. Tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']5 |  H9 _5 F5 c$ }* F0 x
print(li.pop(1))
* f- C; H4 F8 B% B$ w9 Cprint(li)+ h# ?' }3 e6 `- p
# B" a6 y. B5 P
eric
0 {: M, K( I" I$ M6 }0 Y9 f['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 u& V0 Q# Y' a; _9 Q5 Q% i* Hdel li[1:]8 q1 g: H. q& J2 {) n7 Q
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ F# e; @+ o0 i4 B
li = ['alex', 'eric', 'rain']% E9 E: Y8 p; I+ Z2 t
for k,v in enumerate(li,1):0 W0 q0 G! u6 |* B$ ]8 Z6 P" Z
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- P- P1 x5 l1 a" va. 请输出 “Kelly”
, g9 s2 c9 t; D2 E* vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& [  v$ P! v6 J3 v) f) }& d$ Sprint(li[2][1][1])8 X. P1 p( c+ W- q, r0 L4 i! x
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”7 C# B% S( }" F  N
li[2][2]='ALL'
0 g, j" I0 z, b5 l  Pprint(li)9 F% B/ q% L0 O, |5 c$ p- |' m/ ?
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; |9 B( f5 p% U& L. K/ ba. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" v) m9 u* l& c, q" M4 X, X& yprint(len(tu)): U. Z; O$ ]1 s) C, m. v5 m) j
b. 获取元组的第 2 个元素，并输出
! l3 p3 B# p0 |$ e: Oprint(tu[1])/ i4 F4 @9 ]3 Q5 x) H$ d
e. 请使用 for、len、range 输出元组的索引
0 g( {* ?4 B+ d3 V$ ufor i in range(len(tu)) :7 M: I" ]9 I& q$ p( b3 f' w# U
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 a$ i0 n: C+ A1 K
for k,v in enumerate(tu,10) :& g, E& u, K. x- F
print(k,v)  S$ v3 R7 @* r
10 alex
' N/ h+ i5 _, @! U' Q# M11 eric
8 _2 D$ @! L' R8 V12 rain* ^8 G( F' Z" \8 R

0 @! O' O4 i- [( ^for k in enumerate(tu,10) :
2 u$ i. i7 N9 j  r print(k)
8 I' X/ d# \" n(10, 'alex')
( K( z. P2 z! ?  l(11, 'eric')
. S7 ?9 c5 J. o4 y& z# {(12, 'rain')2 k( q6 B; J: z! `' g
6 d! N0 E) W) P! ?7 G, ^* Q

0 B& }4 Y5 a$ E; q) {25、有如下变量，请实现要求的功能
* ~! b0 ^0 F4 h$ ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
; @+ R& B( |* X5 e( T/ ?: W/ I
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
# q3 Z5 @4 ~( M0 J: R! ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])  p# K6 H/ p( ]( {
res=tu[1][2]['k2'].append('seven')4 I4 I+ U/ I$ _! e$ D
- c. H6 H# m  X8 i+ D. X2 F
print(tu)  Z2 j6 C% C5 O" v, y0 y; l% m' o4 R
26、字典& u* C/ y) i" m* m. ]3 `8 c
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
8 y5 C# u! e/ {  R% @2 S$ ] print(i)b. 请循环输出所有的 value) E& J/ O* ^" I0 q" O% X; i
for i in dic:
- h% D8 D, d9 b. V! m% x* P/ ~/ s print(dic)5 f1 |8 x! @' a% Z1 y/ C
c. 请循环输出所有的 key 和 valuefor i in dic:
7 j0 R8 Q' c* u% _2 cprint(i,dic)
' }8 c$ o9 e' `d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
7 I# \" _( z% v# r7 g  hdic['k4']='v4'
0 V( d/ Z7 g" \. l1 j8 M. vprint(dic), I: U+ r3 R' x: n1 L! \$ ^
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
. S' ^' C9 y6 w3 F& M: x& J! B' @dic['k1']='alex'
5 |% j' g+ h6 A: }+ Dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典4 s; z& _$ k( {2 J" T
dic['k3'].append(44)
# A( c! H+ s! s3 T+ v% ~6 x0 Aprint(dic)
8 t5 F/ Z* H; P( V- ?4 j. u
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
  x! G% [4 O( A- `& z+ zdic['k3'].insert(0,44)
# o5 `- ?5 \9 L7 x, N; z6 Qprint(dic)4 Q! P3 b, m# }$ s% I3 ?
27、转换3 e8 j3 X/ ^+ p* t: d- O
a. 将字符串 s = "alex" 转换成列表  s = "alex"
. X% O- P5 K5 Y' F( ]& K8 C: k" K1 i7 X
print(list(s))b. 将字符串 s = "alex" 转换成元祖
+ ?# S$ r) U9 X5 O0 Ys = "alex"
/ S3 d, z: e9 ?3 iprint(tuple(s))2 f, t0 K2 }: W# l0 @0 `
- P* I) ]0 ^% Q4 ~( B& J
b. 将列表 li = ["alex", "seven"] 转换成元组
. R8 y. F* a: \# `7 S( zli = ["alex", "seven"]  b% ]* A& q, x, ?0 h
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表) _! n) o( M+ g- R  L- {# U
tu = ('Alex', "seven")
; m9 M5 J3 C/ a# v: O& Nli=list(tu)2 m& c8 b# ~  u& F- H2 I2 q. v
print(li)
9 N6 [) Y& J0 ^, V0 Y2 x) ]6 R9 G5 v( W% V
: B0 `2 D$ K+ A& E4 `
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
, k" ~0 C( K6 y% i
8 o$ j( f; }0 X5 H1 y5 W3 O! tdic={}, w! x7 G  S" S" F# u
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
7 _- k5 _& j" c  y' ~9 \# M dic[k]=v
6 V1 ^5 a! w; f; r& @0 N print(dic)27、转码n = "老男孩"
# @1 ]9 }" [! n3 H5 K$ r$ Da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
0 I: }; ?0 L& d5 U8 ka=n.encode('utf-8') 3 s7 e  n5 M- d4 L1 ^1 o, o
print(a)- l0 M3 n) ~: x7 {" `) W- R
b=a.decode('utf-8')
2 X0 T, ]3 w2 R4 y3 sprint(b)' b2 A% S: |% I& ?% l& Y
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
; Q8 q2 _$ N. ~' N! pprint(a)
) ]  t1 C( r: Z* zb=a.decode('gbk')0 G( Z9 W4 j3 a
print(b)28、求 1-100 内的所有数的和
: `" x- p' A5 }0 P- Dcount=1
+ ~1 p/ t3 y1 E0 o4 o5 }# bsum=02 A2 {9 _3 A% @' ^6 Q* E4 E7 r7 x
for i in range(100) :
0 D3 m1 [" q" G7 K( F3 X8 a sum=sum+count& ~! `5 e: }2 F& _0 y& g
count+=1
' [6 W/ Y. R- Lprint(sum)5 a. V6 ]7 J% K$ _0 P4 g4 q  c8 c

+ Q* v) r( l' K4 vcount=1
6 y0 G4 J% m- q$ psum=0
9 O/ L" `  U/ ~. j1 g: H" U0 Twhile count<=100 :$ Y  Q! n* m. X; g/ `* f
sum+=count( j+ Q  i, l/ F7 R. Y
count+=1- y2 X: u& ~( ?8 }5 l
print(sum)29、元素分类
+ |" }3 ~/ N$ _+ }有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 c6 ~% u6 d; g5 L7 J& @
将小于 66 的值保存至第二个 key 的值中。
! _: Y$ a6 `7 h9 Z. B' p即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}1 b6 z) l: N' l5 i
li=[11,22,33,44,55,66,77,88,99,90]
2 ?3 o- y( Y! R# fdic1={4 L* ^% P) g: i, E) A0 O
'max':[],* s4 e2 `4 r, U* {$ z
'min':[]
$ B0 z# X% a( n/ _}
9 k* ?: E$ w& T% X5 ^( _# \% E) e4 Mfor i in li :, T. O# W: o, M* h
if i <66 :$ [0 o: P6 o0 N! ]' j% @9 @
      dic1['min'].append(i)7 Y  H! t0 ?7 b" f
else:* y2 r8 h9 g$ A9 t& y( u2 F# Q
      dic1['max'].append(i)8 O( q4 X: ^4 N$ h! _
print(dic1)1 e4 d. H6 J$ @- h5 @. S2 a) I
( C/ X, z. G6 |" @
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
& l: ^& j+ D; y+ m# U3 Z6 m0 Q

Python基础知识汇总

主题推荐