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、写代码
( x- ^( B- g% r2 f( V9 n/ Ta.实现用户输入用户名和密码，当用户名为 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) :! u; b' @) {2 Z8 ~
name = input('name:').strip(). }- S1 v& p: L# T! ?& @* r2 o
pwd = input('pwd：').strip()$ T0 p8 x) ?3 y: @1 I. [/ v5 ?! ?
4 a" b: h/ H  B! w
if name=='seven' and pwd=='123' :
" Y( z) r( K; k  C% F2 m. S       print('ok')! R& v1 ~! J2 ^" J
else:
$ P4 I5 z/ k8 z8 A* t2 q! o       print('error')+ ~+ C/ U( d" k  @
      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)  :) a9 H9 S- |4 R: @
name = input('name: ')
" W. H! Z3 Q! D& V+ c6 \: \9 r pwd = input('pwd: ')
; C; e$ C) }7 i' \ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':* ~+ b; S+ _' S2 i
      print('ok')
  l1 b4 {) m' w- `( S& c$ P& I else :4 j% n) g2 l% B& @1 U# r
      print('error')
9 {9 c1 _% s/ u! q8 q: E9 N       count+=111、写代码
8 O6 O( z# d4 m# W7 k& s+ w# Q: t1 Ka. 使用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) :
, t9 ], A) \* o5 e4 [ if i %2 != 0 :
* E5 A# N% T+ V6 g7 V       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ Y, Y0 j  n, ^6 m( F3 u if i %2 == 0:/ h; l% Z6 {. N
      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"
+ Y+ G+ i5 l; U$ ]  Ba. 移除 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)
4 D( G7 F. l2 Q4 J: X$ n+ wfor i in name:
# h: E* y* S' V  G$ R+ F3 x) q  ~ print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, l" n$ Q: m" g0 J4 c# e8 C
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']* P( U0 Y. b) a( h
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 Z/ }8 c$ o% K  P1 J
print(li)
+ A  i8 Z5 ?. C2 G ['alex', 'eric', 'rain', 'seven']" {2 H: p! r' u' _9 a$ C4 A
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')2 X' z# r" i. O7 g+ Z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')# r) E7 h) Y' _3 |7 z% Y
print(li)
! }  q4 g, v/ {2 I% N$ g6 l' T! Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']. J8 e1 A! h+ q5 x
li.pop(1)
3 \9 m; ^' Y8 m  {print(li) ['alex', 'rain']
3 `& ^0 V/ O2 _% _指名道姓的删除li = ['alex', 'eric', 'rain']
( C  d8 r, Q* |5 hli.remove('alex')  k7 s% z# z0 a* l  Z* W2 X. j
print(li)) ]+ K4 _, ]) z  F7 I
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
1 \5 [2 a& v0 S( n8 Mprint(li.pop(1))
, k/ k5 T9 _: i' a/ b( eprint(li)
" Y3 g0 \* V& z3 `; r; t0 B4 ^- e- ~% r! o0 i
eric5 H- F- d1 f; f0 o
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
" Q# ^! \" j  [  x: s2 ndel li[1:]' h2 v: C% Q, H, N3 W
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)+ O2 L0 I7 c* U6 D1 H/ A; U. ^
li = ['alex', 'eric', 'rain']
' ?4 y1 _* z- ?for k,v in enumerate(li,1):
( B  L* k3 U" \# Y5 n. p! O print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% b: J4 P4 ~$ p7 ia. 请输出 “Kelly”% ]5 ^7 X- M7 `8 `; @8 e# }
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ a/ F+ t7 `( B, F# {4 Q
print(li[2][1][1])
$ u9 \! ?9 p" ab. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- A: P1 X1 ]7 P! Dli[2][2]='ALL'
7 y) f8 C& o/ I* uprint(li): ?9 w- k) o' G# E: e: M
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')' A5 u- J" _% R7 T: n8 T, B# a4 U2 d
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
2 B5 C: O) e' ]( Uprint(len(tu))
, w5 w1 F5 @3 k% \6 \9 n7 nb. 获取元组的第 2 个元素，并输出
( [* R! ^1 x' L1 Y; F5 N; Hprint(tu[1])
7 j4 q! x0 r1 Q6 je. 请使用 for、len、range 输出元组的索引
/ K( Y0 V2 E0 ]for i in range(len(tu)) :
* K2 e. h. `: z, U5 P print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
0 Z4 K! E, H. n+ }for k,v in enumerate(tu,10) :& J4 n8 q( p* t0 C
print(k,v)
" l( T9 c  o% K- p' Z( ?6 X10 alex+ C. O* g( {) V0 W# H- J2 n
11 eric/ L, [( U5 ~* _8 j8 N
12 rain
. _* ~) f4 I8 ]+ H7 j6 z6 m1 c- X, ]+ u
for k in enumerate(tu,10) :
. Y: K% A0 H8 l2 _; W print(k)
& @* y& i; y! z# f+ r(10, 'alex')+ d* K' v3 Y- C  p: _' @+ U8 D
(11, 'eric')' Y9 {' ?5 i, S7 V4 A% ?  t2 I
(12, 'rain')0 k( K' O- u* t7 V, E; L

7 R6 g- t4 ~- e, P4 n- |
6 Y+ n2 ^8 Z# _  e1 x% P25、有如下变量，请实现要求的功能
. p) `- j, p& J' J$ c/ T7 Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ v2 M0 _, _( E: A+ Kd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以: a# T  y1 U4 m9 M% b7 L. z
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) K1 i8 y2 c/ W6 ]1 h% m# y: W+ ]( rres=tu[1][2]['k2'].append('seven')
; Y" g+ S' A' }  E
! @$ e! ~8 [& t5 l) eprint(tu)4 L. c9 Q* y+ @" P4 k+ \
26、字典, ^; m. O! f* @7 O0 n
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:3 x/ Q6 m$ i8 c! x2 B9 d& a
print(i)b. 请循环输出所有的 value& u, Y  f0 K" E: a0 {& y$ D
for i in dic:
% a# P4 [3 O. W; D1 h print(dic)! {) T$ {' X6 |7 v6 `9 s; o: p
c. 请循环输出所有的 key 和 valuefor i in dic:& j. s) C: D# h  P3 n" N5 [
print(i,dic)* Q4 J& a( ^. W; G- f0 O
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% c( V2 c9 k5 D) Mdic['k4']='v4'7 C5 C$ i* Y7 o! t* ]
print(dic)! O% O0 s; D- _4 l
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: h) m) h! M( K
dic['k1']='alex'
* M! M& v( H& ^# P  @print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
- f% [" x# Y( _/ l- G+ tdic['k3'].append(44). F6 I2 Z" C. F, l; C
print(dic)8 x/ z, A$ q; n+ D! m& C2 Z

; P& G3 c1 `% ]g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 V  ~* a, g1 S6 R$ k2 ]3 g$ Tdic['k3'].insert(0,44)
6 G6 c4 R$ v+ }3 ]) M4 Oprint(dic)
* o3 |$ _2 |- p5 F8 |: R9 N27、转换
# k, B* ~  s0 A6 aa. 将字符串 s = "alex" 转换成列表  s = "alex"
! ~  z4 N# Q8 ^3 `1 ]3 s( q$ j' l
print(list(s))b. 将字符串 s = "alex" 转换成元祖
3 B- g. }2 M$ b8 R/ ~. Ls = "alex"
( ]6 V3 h" E) ~" |& Eprint(tuple(s))
4 r. D3 r4 O: K! K  Z4 m& d
2 e! i( v5 x0 R- ~, k# jb. 将列表 li = ["alex", "seven"] 转换成元组
3 i, ?3 k( o; w+ V; @li = ["alex", "seven"]$ s/ [5 h2 G" J$ l7 ^. u; d. r. w
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 O/ l0 q$ Z: o) Q9 {% Mtu = ('Alex', "seven")
, C5 G: d* ^) k# {% gli=list(tu)4 [) ~' D: s/ E3 L0 W
print(li)0 W9 d+ |. @5 h7 [3 ]. l
# u1 S: a0 y& Q- O. `; ?8 d9 b8 Z+ a

  H  j+ |6 s# c5 S* }% S7 Td. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增' g5 x9 M: e. ~
+ Y% p0 F4 y! F5 U& z8 r
dic={}  }- ^- O  U1 C% x& q1 x2 S' Z3 i
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" d/ [! O9 B: { dic[k]=v8 {$ V6 o- y# @- I& W
print(dic)27、转码n = "老男孩"2 [- @$ U/ i/ t9 i
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; n; B; H* c! v
a=n.encode('utf-8') # K& r# _. q$ e. }( p
print(a); @: k- {, U- s' p1 T' I- {
b=a.decode('utf-8')
( s6 b' @. z+ p. C! r7 [print(b)
" z9 s+ z$ c1 g9 F7 {( o7 X2 ab. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 ~; i1 l& q* V5 Q3 H
print(a)
' J5 D+ M) C; rb=a.decode('gbk')( `+ g3 F/ `  C9 @) _+ h
print(b)28、求 1-100 内的所有数的和$ }$ @/ t& D  o* g  @1 R
count=18 a1 F% H6 C  K, {- m6 i) E
sum=05 [4 b" }" G3 S+ f, R. f
for i in range(100) :9 t1 i7 [$ ]& V
sum=sum+count
* w1 q! F$ r) E6 H; J( K- \. B count+=1
9 ?% I, E6 u6 l% K9 M- Jprint(sum)
$ [2 v3 @7 p( e1 }3 I
* c( R7 w1 Y6 f% Ucount=1
# [0 C2 ?+ {  m8 osum=0% a0 i# ^2 P" E% T* I. F
while count<=100 :& c" \' m9 u( L6 q2 n$ J
sum+=count
$ {7 G3 W- i# W count+=1
  b& T2 \& z( _print(sum)29、元素分类
: S! Z/ o) C' d7 u+ p有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
3 H+ y6 T* y- X, Z0 J将小于 66 的值保存至第二个 key 的值中。+ V& r; g/ r& p' c5 b. P7 Q0 ^- r
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 J  H" @$ @5 H
li=[11,22,33,44,55,66,77,88,99,90]0 y' M% X  j% W/ m
dic1={
" i0 w. x8 w. _! i1 n3 O 'max':[],
# Z4 i6 s, _& }1 b 'min':[]
) F  J* E8 m1 Z4 v, C/ ~}
7 s: A. G3 `3 ^+ h5 r5 Efor i in li :
7 ?% V! a5 Y; t; M' b6 D+ T' W1 e* g if i <66 :, @" f1 T4 A* V
      dic1['min'].append(i), y' c* M9 _6 r- Z! J3 ?+ I# B
else:+ |1 S4 ]6 p  ^0 O7 D
      dic1['max'].append(i)
* D1 b- Z, `) t2 K% a  m3 Uprint(dic1)- Z/ r+ [( h7 \

& J; |! S' J2 E" c" X7 Z- E---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( B6 U/ n6 a) ]+ {8 [. d1 s7 u# _

Python基础知识汇总

主题推荐