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 O  g4 q. L: m" L. Za.实现用户输入用户名和密码，当用户名为 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) :) U3 o  i/ X# q# r7 C4 n. T) |; `
name = input('name:').strip()! v% h5 c2 x* x* d& u
pwd = input('pwd：').strip()* j. H4 |% ~2 G

3 y3 R5 s. F8 R0 D- z! b! \ if name=='seven' and pwd=='123' :
: M; b5 e8 p3 w; d' S$ a2 \" T$ }4 ?       print('ok')% I& ^" N' O' U- b
else:
+ D+ d/ N5 |8 d) g1 Y) {) [       print('error')8 s1 ]- `, N$ b5 A3 p2 T
      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)  :
& E8 H/ W5 V5 z" A! D0 {9 e$ P name = input('name: '): b' d1 O0 f& X& Q; S  u- Y3 q* B
pwd = input('pwd: ')
- s/ @, d# W1 G3 }; e: P7 ? if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':1 i3 P6 W1 u0 T0 E& O  N& K( j
      print('ok')
  ~0 B1 s# T9 J0 n% p  T. W8 ^ else :
( N5 s) J3 W' j% J  n! v+ L$ B       print('error')  h% c( q2 t% k( \
      count+=111、写代码  q! {1 M( M2 {% i* g
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) :; b* c" v/ j, ~6 g& n* R9 L
if i %2 != 0 :
7 b6 c3 O0 |7 w  c       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
# Q9 G! L& p, w) k% i6 q if i %2 == 0:
2 m- Q1 z1 E7 @8 \1 ^* S$ b       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"
; ^9 ~2 ?0 f* v8 N7 i7 N! K# O7 aa. 移除 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)1 Y1 e- s$ H: j' K
for i in name:) o: m/ v9 N- p# r9 `
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
6 j  E5 z. @8 G2 C+ H; i3 F22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, s1 r$ y2 L; B% p/ Iprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
' Z3 @2 K5 P$ z/ l/ nprint(li), I. y! a4 o& e
['alex', 'eric', 'rain', 'seven']
- Y& X: c7 _+ F" }% dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
& B0 |& a7 V9 W8 r# Xprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
4 m0 k& G5 B$ d* ~: s$ y, iprint(li)
: P( t" C2 J6 Y/ c- P( f1 \8 ?e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
$ r, S) U  l, {( vli.pop(1)2 q, M. Z( C  y3 l$ w
print(li) ['alex', 'rain']
7 o% j" F3 }2 p# ]- U( F# ~指名道姓的删除li = ['alex', 'eric', 'rain']
, }. q$ s1 Y  Jli.remove('alex'). k: \" J; u+ M5 b
print(li)
- b3 i6 n2 e  S4 g3 mf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ f- Y0 g# v4 }2 X" `
print(li.pop(1))
7 E  R4 v* H- h5 |print(li)
: ?/ D7 S* \' W0 M& ?
3 B& V/ v" l* deric
2 q6 z9 F8 F6 y, S. H- B['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']* q) y: i' l. ]: m- H
del li[1:]
6 q: A; n- T) E* d; fprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 r$ I5 a+ Y2 I6 c) L: l- t& H! uli = ['alex', 'eric', 'rain']$ |& @; A8 M% `) G, y
for k,v in enumerate(li,1):
- B; q2 @" g/ [( F# n print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 C" C( V4 n2 J' @1 I  p! L6 qa. 请输出 “Kelly”
" T% z! H$ t# e+ vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 s! E, _5 l0 ~
print(li[2][1][1])3 v9 _; D# g& B  C
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
/ M8 d( k, J( {3 sli[2][2]='ALL'
$ m$ K3 W/ P8 \print(li)
) {& h; J  {7 x24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
8 Y7 O( g1 J; v4 H4 p. K- y/ t( ?1 Ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')" w7 W  L: n+ |9 Z& n
print(len(tu))' k2 A6 h8 c7 I, M0 i) l
b. 获取元组的第 2 个元素，并输出
6 ?& |6 y0 e6 p, d7 E) S) D- n/ h3 W7 iprint(tu[1])! X: g4 T! T9 U
e. 请使用 for、len、range 输出元组的索引
) \. c  m9 b/ d: B& H7 K. Ofor i in range(len(tu)) :
" Q3 q2 G* I6 H/ t* W, G- y print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 m: G1 x" |. S# F: U, s) sfor k,v in enumerate(tu,10) :
* G: J, [  H+ h print(k,v)2 ?. i2 Y: ^# R# Z4 D+ s' l
10 alex
7 G: N6 F  ~  j" Y4 X: z11 eric
( j% o( D+ T9 U8 a0 F* A2 z* r4 l12 rain. F6 m* p: r* \
# S/ A3 y! G' q% T2 T# P. O
for k in enumerate(tu,10) :
% [# N$ x) d( H* a' h4 q7 A print(k). Y* n+ k7 R3 t
(10, 'alex')
(11, 'eric')
; v& K( b) i' g7 F" y(12, 'rain')6 U" q( n' x$ w& V
. J$ l/ l+ M+ Z/ _4 l% P

! ?8 i( H' ~- p3 a2 R' {25、有如下变量，请实现要求的功能8 L: d: ?1 D/ O0 P8 q4 B% A7 a
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
8 T! ?/ b* Y3 A6 U3 X
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以2 s% u- k5 r' S' p( p9 n7 C7 b
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]): ^) k6 }9 `5 s" u. V# n! M4 \
res=tu[1][2]['k2'].append('seven')- X) O, p+ X0 G: n$ x* X
$ k2 R0 I, U, p8 n+ z* k. X9 K  }
print(tu): E& X5 V/ V8 |% ^6 l6 ]
26、字典9 w2 l  y" d) g2 e* G5 W6 y
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:; K. M2 G! g$ _
print(i)b. 请循环输出所有的 value' E! Y4 A- h4 J8 o' B
for i in dic:9 b, F0 o$ w% L* u* d
print(dic)
; p2 a4 k6 W/ W) }4 I) K( ^c. 请循环输出所有的 key 和 valuefor i in dic:
- o2 f$ y, `+ q' @8 c3 z7 Oprint(i,dic)( |, v; _7 A0 C, J0 D
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典- C" M9 @5 o& c6 ?/ N
dic['k4']='v4'  E' h* N, n+ u+ q# R7 e$ _
print(dic)
; J. R0 t1 D+ me. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ _# m. C2 y* [6 T9 e) _; Rdic['k1']='alex', _( ^% R4 `/ h  b9 Q, M$ T
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典7 `7 q5 k) ^4 i) O8 M4 K
dic['k3'].append(44)
' k- q/ @2 `0 t4 e; B, w. q; u0 Gprint(dic)7 z4 l4 q* \1 |9 W% T8 c

+ d( P( j6 c5 x7 _6 rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 A4 Q" x$ N% j3 Q% H* u; Y+ Bdic['k3'].insert(0,44): q% ~: Q, [! u  f+ D  W7 E4 X2 D
print(dic)
& z3 Z+ Y+ ~% p27、转换
! K1 b6 N$ A: Ya. 将字符串 s = "alex" 转换成列表  s = "alex"
3 @* W! Q* P* v3 h$ Y5 N7 r) a+ q; q" u
print(list(s))b. 将字符串 s = "alex" 转换成元祖' K, p  A# N! |; {3 p
s = "alex"; }+ o  K3 S; X5 |# f; H! E( m
print(tuple(s))) A1 x) |' w: J% Z% }4 m, V. C

# s/ u  z2 N& {- }) u9 Z3 ?. ?# Gb. 将列表 li = ["alex", "seven"] 转换成元组
; P9 H  T3 N6 u6 K4 Pli = ["alex", "seven"]
7 t; `5 ?% ?* u% ~8 c( Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% C5 T* N( E8 P- w# M+ }tu = ('Alex', "seven")
* a; u6 Y9 c1 ?/ l5 ?% Q/ Lli=list(tu)
2 Z9 F8 V7 ]  O" O  r, Jprint(li)
2 b6 _* ~+ m; ?8 g$ T: J" v$ b' j" \! A) Y' z3 p

  C, x& U# V( a: ?9 Jd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
3 x7 R( q) s! D+ L1 i2 F0 x4 _7 B( f
dic={}
3 A0 ^. @  L; d+ Vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
% q* d& c# |- a, _  ] dic[k]=v; S# X3 E8 C0 z" h; n; R
print(dic)27、转码n = "老男孩"6 \5 H! o& z2 m
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"/ F3 d9 r! Y6 m- w8 o. q5 ]3 J
a=n.encode('utf-8') & I0 a% R' X7 u3 r: j) \  x
print(a)+ r6 n. s! e: w  g# M+ E
b=a.decode('utf-8')% f! T4 Z  [$ G& D' E
print(b)
) Y4 X3 F* X; g3 d1 zb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
: N! }5 i2 c  Lprint(a)
; l: b: e* b9 ~9 T$ C& S2 g* xb=a.decode('gbk')6 [; a: Q  ?! J; n
print(b)28、求 1-100 内的所有数的和
- l. S3 i- k) S' R0 I- S) gcount=1
8 \: u; ]  q6 D2 g1 [' Psum=0- R2 `7 X% Q% }
for i in range(100) :7 w, Q' o' b+ {5 {  W- D+ f
sum=sum+count
& C" U) f$ z- D; q1 y, h count+=1! g+ V5 y* E% P  T; P
print(sum)! W' Z, @+ n' \& @  u5 j1 {3 x

" T: {: a: B0 Vcount=12 o  G) `2 O9 O. E- L
sum=09 {6 ~: s4 u& o- e# E
while count<=100 :+ X5 D7 p& z" `5 j3 x6 l+ P
sum+=count* ], ?* l4 |% y8 `* U/ N: |. X
count+=1
! h/ i  w2 @+ j6 _print(sum)29、元素分类) x* v9 y. a5 v: B0 e9 {) D8 r; o
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，* S& c& |; k0 O' @+ K0 a
将小于 66 的值保存至第二个 key 的值中。, D( _3 {& X1 L9 `$ z: I! |+ t
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}5 t! n, c$ {% l/ o: ~
li=[11,22,33,44,55,66,77,88,99,90]
8 S0 H5 |1 J9 X4 z8 z: bdic1={. [& z) J5 o6 D' _
'max':[],: ~2 v# S) E( @
'min':[]
) q# _# ~9 _4 d& r; z. b, r}5 q4 [! e7 w" R) Q' z+ U
for i in li :: @/ g; B/ ^9 ~6 ]
if i <66 :- y5 p( o! `0 B6 v1 w7 M7 ]
      dic1['min'].append(i)
9 U3 v6 u" w: ?8 i else:
* S% ]3 Z  b4 O       dic1['max'].append(i)
" x# [& N. f! Fprint(dic1)
" h0 l& |: A/ O9 E
; D; Q, q% y$ P" X---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}6 m& q$ P$ k9 H( L

Python基础知识汇总

主题推荐