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、写代码; N# B: X" q+ r& g* C, V$ q) S
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) :
5 r- N! p" }& e name = input('name:').strip()  k: A6 O' Q+ j2 g0 ]
pwd = input('pwd：').strip()- Y* d5 {) p# o, {

% v! X, |; D" x# p7 _6 k if name=='seven' and pwd=='123' :# R; j4 J& A: d
      print('ok')
  L) n( F" q, V3 q) e1 R else:: k3 t9 Z- r. U1 ^4 ~0 ]( T* s- u
      print('error')3 r( R1 V8 }) [( ?" _: H
      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)  :8 C1 O( d) g) T$ K& z. b
name = input('name: ')
9 b3 f! o" _: P* p: m- s8 q pwd = input('pwd: ')1 j8 r$ k" C! h$ h7 @* `
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  L  N' w0 @- O$ ]) {# J$ @
      print('ok')$ Q2 R8 N3 u( R, _4 p
else :
& j) X- V/ S' k" R6 _2 V* S       print('error')
, C# S: B) G$ }% d; w       count+=111、写代码1 g2 z6 t% |% O$ `7 k. X* ^
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 L" d5 c$ B6 W' _8 N5 _% D7 d# h9 i if i %2 != 0 :
" e+ j* b2 l* ~6 ]  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) :% c) h1 s/ H; _& l! V, S9 y5 P
if i %2 == 0:/ A0 U, E+ p3 b7 t
      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"' g. D+ U+ {# _$ v, }4 Z/ R/ l
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)
: ~% a1 B  j/ S( o) Sfor i in name:
9 I1 E# h! a* k) [* T print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
) q: ?7 Q( w5 U7 @1 G22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']2 H; c, D0 V- j4 e' H% p
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    9 Y# P+ t, I$ n# G$ ?+ a" Q
print(li)
& ~5 v4 Q# t! a" y2 c$ l ['alex', 'eric', 'rain', 'seven']7 O6 ]% c! Q/ A0 K5 c3 R4 A. t1 P- l
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'). y4 h9 y+ W7 F1 x) T' A
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
: L0 l( q; L: iprint(li)
9 e9 C; G7 |0 o9 J; e  se. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
* {3 e: R8 k! Y; o1 C$ M5 m: X0 r2 ili.pop(1)
/ _" ]7 K9 `7 K  sprint(li) ['alex', 'rain']. \- }$ _- [1 U7 e
指名道姓的删除li = ['alex', 'eric', 'rain']/ e# r) R! G4 s$ v! c( r
li.remove('alex')8 ^  X7 F8 k" c! b, c0 k3 U
print(li)" k$ I) d; `. _0 b* H% f1 Y7 G
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
8 l5 h$ L3 l  h1 qprint(li.pop(1))/ a7 u9 [8 D" o6 E2 c" R( T0 `# T
print(li)
7 @8 w9 X) h% \6 Y6 Q, P" Q
' i9 f+ `- I) z4 z/ p/ _$ Reric% U& m, |6 w" q* Z. J
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']" k1 O9 M" U* |4 l) G; }0 Y. N
del li[1:]; x) b& l- l! C" f( s! _6 J% {
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
+ x3 ?4 Q) n; r' h; M$ w2 M' tli = ['alex', 'eric', 'rain']/ r; u$ v$ Y  p9 m4 [6 X  g
for k,v in enumerate(li,1):6 R6 t( b* ^) G$ h# t0 ^; D
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: O/ n4 |( h* u; N
a. 请输出 “Kelly”
1 D  U; ^6 k; \. x( zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! W* h& C- D1 F) A9 y
print(li[2][1][1])
& u/ q/ W% ~8 W, S: ~9 Mb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
. w7 ~7 Z: N1 Fli[2][2]='ALL'+ U% Q# T( ?) z* s0 T
print(li)
# @3 ^) ?$ ?$ [, c1 }+ H! b24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# x6 }' }9 ~  a, o0 o2 ea. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& g  W( B: d: h8 C" a+ Jprint(len(tu))
1 a1 W+ q5 z1 o0 \7 l0 u- V5 b" ab. 获取元组的第 2 个元素，并输出0 V! u0 L# f3 \  r2 }" v+ z! ?  T
print(tu[1])
  t( f( J$ ^) k) F9 J; N1 e) r  Re. 请使用 for、len、range 输出元组的索引) Y( F, S/ k+ C. i5 Y, f
for i in range(len(tu)) :) a$ e6 ?0 Y9 Q
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: f9 k- u: e( h: pfor k,v in enumerate(tu,10) :" V9 j; S# n8 `$ _
print(k,v)( k6 p- N( U: }! S
10 alex
5 }0 ^8 E2 |/ C# t( Z0 E' A1 B0 u7 V11 eric! i% Q0 [$ b. C( T0 b! c
12 rain8 K0 |# b. O! R5 }
0 v! o# }! P5 `) u
for k in enumerate(tu,10) :
# Q6 ]4 G! U6 j6 w* a; I print(k)
5 a6 L6 w7 A7 E% ?/ t; g+ N4 D" z(10, 'alex')
6 ?8 v  U! \' G3 S  ?(11, 'eric'): D( h( f, `- i" H$ w, a+ I
(12, 'rain')
* T; W' a/ F! I, }
, s+ [' ^2 a! G( O
" S, n: G" m  J; s# e( K25、有如下变量，请实现要求的功能
; r) P0 z* T# s% u: _: _+ ?' o6 u* Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
6 x8 r, v# s  a4 l
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以  L) A0 [/ ^4 ?( c$ d6 A
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])4 N' i" I/ |, r9 x
res=tu[1][2]['k2'].append('seven')
/ v. e3 V, E$ r" y
2 C! u  `; X% H+ k/ L( aprint(tu)# G! _) `. [% @( d
26、字典
: n) S$ E* W! b) i! ^2 P: Sdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
+ x1 s3 q" }2 _3 r& Y) T print(i)b. 请循环输出所有的 value3 V; p0 h" g  I( R! z
for i in dic:
! S9 ~: w+ W9 x2 t3 G print(dic)
' c, h5 j8 K3 v7 C5 pc. 请循环输出所有的 key 和 valuefor i in dic:
: f. F; Z- `( G8 J& _( qprint(i,dic)
* r$ m* g, F  f) o9 ~d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典2 \- P4 @( \. j
dic['k4']='v4'
0 T9 o' x& h! Y8 J9 g2 w& f' W! Z  nprint(dic)3 K  X. H0 n& n& \  z1 ?
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典; j* M# H7 j$ b) n3 }3 k
dic['k1']='alex'; v8 V1 N# F! r, {1 \* d
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典" ^1 V  |* B. R1 I  ^' N+ D  v
dic['k3'].append(44)3 `6 x( Y( Q9 W- @: e& m
print(dic)! d# A9 S- i- N: N# U! k" e7 d* `

5 j. _: \' E* i% ~+ k7 |' Jg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
: _6 o7 W$ u# |+ M: U' x! Q& c( Ydic['k3'].insert(0,44)# c9 d# F# E+ ^9 i
print(dic)* N5 [- w8 i# |' ^6 n
27、转换
$ B' V0 H  v) s$ W0 Q: }a. 将字符串 s = "alex" 转换成列表  s = "alex"
' s6 H' ~' _- A, R% V  @, g8 l: y/ y6 c6 I8 B% ?! Z
print(list(s))b. 将字符串 s = "alex" 转换成元祖
5 F& D' |9 ~; d# H8 ?$ ]$ Y) r3 c8 as = "alex"
9 ]3 E- [1 w& @! o8 s6 \. \print(tuple(s))
! K2 @- r" O) R  ~; r5 l5 w3 Q# E/ c7 F) O6 e
b. 将列表 li = ["alex", "seven"] 转换成元组9 X' X# y4 C7 O0 z4 z% P9 D
li = ["alex", "seven"]
6 E6 d: ^+ v; g# |5 Y3 j+ F0 Aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% d- {3 @) p$ jtu = ('Alex', "seven")
- G9 h7 w# Z5 Jli=list(tu)- Q7 R  _1 ?/ E) L2 h0 d' y! U
print(li)* V( f9 i# {) D8 }5 F1 q, N
! t3 P& k1 J2 a1 r1 E# o0 D  D3 h! }

# {4 i+ @; d3 |/ Q* sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增2 I" B" p2 n6 z; |0 V6 M; S

; G+ F6 ?9 k+ v# q9 hdic={}
6 c" H3 m1 X3 i, wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面- Z8 W; T9 |  k
dic[k]=v
0 Q, o# ?7 ^- |1 B8 e1 U6 L4 V print(dic)27、转码n = "老男孩"
: B0 p: D( [' C1 t6 S( {a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# z5 ?- M" Y4 q& n+ A  N: u5 _# u. za=n.encode('utf-8') + \  a9 F/ U) M* U7 p1 h
print(a). a; n" z) ]3 n9 V* A5 h/ l
b=a.decode('utf-8')
& T# n6 E+ \- y; N9 N1 g' |* kprint(b)- N$ b3 E9 L5 e1 b; C
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: h- ?2 P/ i# Z& L8 |* c' B4 fprint(a)
" C, [( J# Q5 Y! V& P* \6 G" J0 jb=a.decode('gbk')+ f1 V* _! o$ U0 Q
print(b)28、求 1-100 内的所有数的和: g; R. O  X* l& i7 @
count=1: R$ {& R+ p8 P  ^6 P" R" Q3 d% ?
sum=0
. n% p3 ~8 a/ [for i in range(100) :2 H) ^! {: P0 w, X
sum=sum+count  Y: F1 T# Q7 `# n/ U& K
count+=13 S. n+ C4 o' {5 H" Q
print(sum)
  R) f& e' Z  G4 R! L* [2 I! r' t' d) N) B) ^( L
count=1
9 x; _' _7 y8 z8 C/ E; ~sum=07 s" k% W9 t/ l* i+ K
while count<=100 :
6 [. b" A8 m6 r- }4 [% v  _ sum+=count
( N1 z' `: \6 Z  V- N count+=15 F- L- G. F; y" s4 B5 f6 |  P
print(sum)29、元素分类
  {5 I" d0 v2 W8 d! ?: V有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，" l$ J8 n6 V0 j6 v; J/ {8 p
将小于 66 的值保存至第二个 key 的值中。* G' q3 y0 g+ o& t9 s6 v2 h: ^
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}$ n4 U% o$ j+ Q* ]
li=[11,22,33,44,55,66,77,88,99,90]4 b' P" e, m* k
dic1={
0 ~9 F7 ~; S8 J; b  r 'max':[],- A7 X( v; |5 ?) M$ l9 d
'min':[]
8 w; ~$ {7 m# [/ h8 W  A% m: E}) f+ T) J6 e1 e
for i in li :8 X) B  D. \2 B3 P; n1 x
if i <66 :# w. }% t6 f5 J8 e4 m2 w
      dic1['min'].append(i)9 e8 B; [' _1 q9 n" [# F6 H
else:* N+ j9 P( G2 m8 r2 @! h; m: G
      dic1['max'].append(i)
  y0 |9 U: m7 p8 b- b9 U" t# Z1 zprint(dic1): a. d2 e2 ]4 j
7 ^& b& i% z, |# [2 R& F
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 K2 j; D2 f5 W, x) V' R3 Q

Python基础知识汇总

主题推荐