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、写代码
/ B, \5 E2 N3 h' y4 }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) :- s& n# |$ e- Q: Z+ t, T5 h8 C/ J
name = input('name:').strip()
8 T) `& [4 x5 w pwd = input('pwd：').strip(). n0 c6 }# b* t6 i2 y, r

* u. }% \3 T" j  Z8 X! L0 b! s if name=='seven' and pwd=='123' :
* Q* q2 S3 s: @9 S2 v# i2 _$ o& }       print('ok')
/ K3 d) L- g/ j5 ? else:
( k) N6 o! J, M9 q! t6 |+ @       print('error')
* z( ~. v2 ?2 D8 f" ^$ 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)  :' q$ t, U# q  Y, J' Y
name = input('name: ')$ {) A3 v* I! k! m
pwd = input('pwd: ')
, z/ f& i- ~/ T* M3 c if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. A' O- @; {- a9 [9 s       print('ok')% |0 K4 u. g( w* S6 G" D* p; \
else :; q% T4 s6 g3 D$ h
      print('error')
6 ]) T! s4 B+ t8 i8 L       count+=111、写代码6 N4 U1 H( c; S* r; I8 P
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 a9 x1 X2 G+ ?* e2 A3 Y if i %2 != 0 :1 F! K) l# n/ R& z5 b7 q9 F
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
# Q0 d0 }. l; \* k$ f! T if i %2 == 0:. i. ~* Z* T$ a/ |
      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"
$ [* ?' V) u6 Y6 A! `  `" Xa. 移除 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)* T/ P# d! r# |2 ]- A1 a
for i in name:
( q; D. }7 c. T print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
9 N. C* X8 p# n22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']5 e0 x& I' G" r) Y0 I
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
. c7 F* Z$ A& y3 r5 t  |print(li)
8 l7 K5 e2 s. L! P ['alex', 'eric', 'rain', 'seven']
/ z3 d" [+ r' Z0 [9 S0 q' a* tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
1 d0 Z# `% \' {2 g+ yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')( _- Q1 ^& D% V: ?+ q( M( H% S) g
print(li)2 `& D# p  Q3 f( @3 Q; R
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  V' m( c  F7 X: F7 f( }li.pop(1)1 i; x' }0 o+ {2 @: T4 _( L3 e
print(li) ['alex', 'rain']* t5 r5 T' T3 @
指名道姓的删除li = ['alex', 'eric', 'rain']
- m3 z' L3 ~8 H4 T/ W+ U2 [li.remove('alex')
8 {6 J) @; N& v. K/ Xprint(li)
# f( x3 h7 S0 c/ Df. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']4 R  j6 w) `: S
print(li.pop(1))
$ h  G0 W4 U. a: {1 Qprint(li)/ y( D3 W4 S+ L0 j, x
% O9 z, V; M+ ]% M9 f( X
eric% P' K0 Y6 `! u0 d
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 ]' h' X1 E' M% M0 @del li[1:]
( c! a: a) H( p) u/ Jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)0 S0 _0 S* B- S% @5 h+ A! Y
li = ['alex', 'eric', 'rain']% D) x; c$ Q$ a& A" Y
for k,v in enumerate(li,1):
' k/ Q+ p7 J2 d# ] print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 B- O' ^  n/ w, t( W( J  W( |" Ma. 请输出 “Kelly”1 r; V8 C, u' ?6 M
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 K$ g4 @, P9 t3 f: ~( t- w! K* Bprint(li[2][1][1])
* s; a4 S9 n% Q6 q! L- ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  _$ g+ v* M) \# l' ~  J: Tli[2][2]='ALL'8 J( k( F0 s) `; o+ K, G* Q
print(li)
" D% ]) o( r+ z. ^5 O6 t# W24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- `+ [/ w/ n2 Ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')  }& N9 K7 O$ q: K5 s
print(len(tu))
, ~, ?8 I+ u) C& \9 v" Fb. 获取元组的第 2 个元素，并输出
" e/ h+ F1 `$ F3 o1 Z+ k, Dprint(tu[1])
7 [2 W8 V& ?$ E* qe. 请使用 for、len、range 输出元组的索引; X) X. a% R5 k3 ^8 @( I6 f
for i in range(len(tu)) :% R8 @* _( M$ v
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 {1 u: B, N0 n8 y6 Afor k,v in enumerate(tu,10) :# @5 `6 P1 F$ t, G0 y8 T
print(k,v)3 W$ d, `& r( C( G. [9 E0 h, U
10 alex  ^5 c- j& Z8 O3 I  h$ |
11 eric4 I4 l# f" D+ {  k! Y5 I
12 rain$ l- ]9 u$ p0 o' n5 z% r1 B$ \. D9 s
8 ^: y6 {# F8 {& V3 `( `
for k in enumerate(tu,10) :  a! a! r- ^% `- ~" F) V
print(k)& M* \7 Q2 v& ]( n/ D
(10, 'alex')8 p" }' ]% i3 }: w1 {
(11, 'eric'), H# S3 x$ L& v8 M" Z  J$ @
(12, 'rain')* e+ M" c8 O: H+ O0 _

! J3 I' ?: w8 L1 Z' I4 W" e- U$ E$ T! W7 X" T7 F  o
25、有如下变量，请实现要求的功能- s3 t  W  p( z7 l1 [
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

, A( `7 \; N' `: @/ rd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 F- ^4 a( }: E- `) ^tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% [2 e4 D! H! y3 h- Nres=tu[1][2]['k2'].append('seven')
7 V9 S. P  I! T' M! x- J# J
. I7 E9 @2 u" E8 o3 a7 o2 rprint(tu)
- H0 P7 C; R: Z+ J26、字典# P$ o; a0 V/ d& z6 ?# U8 p4 F
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:% K/ I7 m& f% G5 y) r
print(i)b. 请循环输出所有的 value
2 r. o2 [" J8 ~for i in dic:/ ~3 g* w5 _  w$ J$ V6 u
print(dic)
3 H3 |1 r- ]. m" K/ N5 Bc. 请循环输出所有的 key 和 valuefor i in dic:, V) {+ D5 P8 ^% Q; P& b0 B4 h8 Q. Y
print(i,dic)6 e) Y( ^4 w" m* m1 i
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典  ]; z; H+ o, T8 D
dic['k4']='v4'
0 J- n1 e3 I; T* oprint(dic)
0 H% A! v& {7 ]3 n8 je. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
' {1 \- m1 X) ^  I4 c, R/ rdic['k1']='alex'( C' N; T2 h: w7 b% Y: H+ ^
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  h3 E9 d& E# f3 b( U8 [
dic['k3'].append(44)3 O. D8 q- E  |' |- f6 g. N* G/ m; c
print(dic)
; V3 w, j) L3 m* J( R: b( V
( l- U2 V! s- |g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典/ V5 G5 ?' G9 [3 l: A9 @2 y9 a
dic['k3'].insert(0,44)
" q  Q6 M+ @& f0 C' a' u* Pprint(dic)) `6 v! _  U) V( W
27、转换+ v  f" [/ t1 F2 [3 @9 S/ U
a. 将字符串 s = "alex" 转换成列表  s = "alex"
* X% |) O9 e% ], e0 B5 P4 `; C$ \: I4 Z5 v; P6 G. `0 s! k* o
print(list(s))b. 将字符串 s = "alex" 转换成元祖
1 G% L0 O" {  U6 g# }# x+ Vs = "alex"
9 v7 C6 ]6 x7 c8 N9 }print(tuple(s))
- k& z& p$ m- Y  C- I7 \) h2 y$ ?2 G  ]+ U
b. 将列表 li = ["alex", "seven"] 转换成元组7 Q0 u9 D: ~, E  a
li = ["alex", "seven"]" q4 p- W0 u( P0 |; j4 K  g+ y
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表/ {- @4 f' _0 X2 S* ~5 t
tu = ('Alex', "seven")% |) [5 Q% c% K4 g: q
li=list(tu)
  x7 l" Q$ q* a% uprint(li)
5 i& C8 g6 x8 o% S# l$ w
8 m9 m5 s0 e7 s* R# {
+ ~& V# X9 P& bd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增! i" l' H0 q7 A" i3 k
6 V3 t5 n6 Q  j5 g3 {2 M8 e6 M
dic={}6 A1 |: F; y, D* t4 Z1 U+ ~
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面/ z! C5 T) i, z
dic[k]=v- c6 n8 `0 E  f$ E0 |! [$ |
print(dic)27、转码n = "老男孩") w) p2 |  _0 V- d- ~4 @
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
9 W$ w0 q& s9 E7 @5 r8 F, g" Ea=n.encode('utf-8')
" A- }1 F, o/ J$ t2 w+ \6 C1 Eprint(a)6 h" z+ D/ I& h: j6 O. ^3 I
b=a.decode('utf-8')
& D4 q2 T& v/ Z$ o- D4 M$ Mprint(b)
9 B1 H& y3 F% }4 {0 u$ Vb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
1 J9 W9 {/ X7 N% r  c; ]print(a)9 Z0 S+ l7 W- H6 r$ c- m
b=a.decode('gbk')
* Z5 O0 \; u& q; ~5 R: X* Rprint(b)28、求 1-100 内的所有数的和
9 _0 w; ^( M/ O. d+ dcount=17 G) `" Z: u4 f+ [6 ]
sum=0
" m% L' G: V' |$ h# @for i in range(100) :
4 ^5 @9 V  a( f( P. j1 n' Q' h" E sum=sum+count
5 \3 N2 x/ m; l7 h7 x' X4 X count+=1
- N5 z- {2 e+ m3 oprint(sum)1 F( X8 C7 U1 B+ O) _! P

# `9 q6 W* v. w" y, E+ k# `) n3 wcount=19 Q+ J; k3 ^4 k! C, S) a* u
sum=0, k" X5 P! W2 w' [! ]  Q- Y8 f  |
while count<=100 :
5 @+ J+ v1 s: v4 C- L. J* i4 G0 D sum+=count8 F1 s! s! [: w8 r7 D) [
count+=1
) E5 X4 [+ ^3 W, f! c2 |/ t. v3 Aprint(sum)29、元素分类
$ e' m1 W* ~6 P6 K$ K! G. B' G2 B有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，; o/ m: {* P/ m/ _: v  q
将小于 66 的值保存至第二个 key 的值中。
/ d- [* Q5 k1 E6 M7 b即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 r- B" s2 c7 `9 nli=[11,22,33,44,55,66,77,88,99,90]
( }" x6 ~" F4 g% G' a+ jdic1={
( p3 j! T% h+ e3 W5 `9 z" f 'max':[],
* O' U! i& S- I, o: z/ ` 'min':[]/ F- }8 }  @+ A
}) m7 y& y/ i( K1 p/ `
for i in li :
6 R3 k( z- c/ g$ R/ o if i <66 :
! U. g1 F5 q* z       dic1['min'].append(i)
' d" k6 C+ Z( P else:  o8 |0 m' x. `8 r
      dic1['max'].append(i)2 e$ Q8 H3 o4 t8 {$ K! a, e
print(dic1)9 R/ }% N$ V& ~& L& @2 m  C7 M, t* S3 A

/ {/ C/ H1 Z* N- W) M. B---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}$ c/ f5 U2 _( C; `2 _/ |5 ^

Python基础知识汇总

主题推荐