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、写代码$ l' U' L- o7 W/ r8 w+ W  [
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) :
+ u; a- a6 i8 o name = input('name:').strip()7 w2 b2 F. j* `% [# u+ f
pwd = input('pwd：').strip()
" ^% \" v: Z8 E1 H3 u/ `- v- }% B9 H) B5 V1 ~( s3 z
if name=='seven' and pwd=='123' :9 \9 Q4 h) o7 a4 r5 k* [' N
      print('ok')
* ?' T7 _( ^! N$ {8 G else:& f6 |+ H9 F, C! W% f% K+ m. e0 w
      print('error')
1 J6 W! w; [! v; V/ i) u! S3 |& 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)  :
% ]% a; H2 a* Y6 @+ V" |% V, y name = input('name: ')! a% A& ^- R- t, F1 \
pwd = input('pwd: ')
- k. M) C9 Q" m; F% E6 i0 p4 { if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':1 ^$ b8 o9 A' ~. F2 x3 q
      print('ok')3 w: j; X9 }, l7 L
else :
( I/ s9 s) v) V. t       print('error')
0 w4 u- @8 y' A: i" }$ z" n# D# W3 t       count+=111、写代码
$ ?$ p7 F' A& o; Ra. 使用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) :' T8 y+ c6 T/ i. g. ~3 N
if i %2 != 0 :7 d* N  w* x' p) T
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
. S. R' _# N3 x  E! t if i %2 == 0:& o% ^% v" C1 Z1 H4 ?
      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 r& }# t  o) K6 m; g7 ra. 移除 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)+ a4 [0 W3 \- f0 d! S9 X
for i in name:
$ \4 U& ^: _, P print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
2 b( a2 K% T. _9 G3 G* ?" L! s22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']' g0 L( o" u* A/ f7 d5 q7 g
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 a' S: A$ i7 ^3 |print(li)
. U; ~9 U1 s* ]' C7 d# Y! } ['alex', 'eric', 'rain', 'seven']  X9 u9 q4 G  _- v$ K$ L+ d
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); L* ^7 G! J8 }! j5 t9 r
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')3 K% p3 W: n; j& d, H
print(li)
: e) T! a1 s3 g, U. ?  j8 e- `2 ae. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']% M9 `: c* B# T0 `* _- U6 ~' ]
li.pop(1)8 ~% X. F8 X7 k4 `0 i0 J0 h
print(li) ['alex', 'rain']
* e' e6 J8 n: }指名道姓的删除li = ['alex', 'eric', 'rain']
: q1 p( {& p9 Cli.remove('alex'); I; J( f* F+ E
print(li)7 |' Z! m, g$ V2 |3 c
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ p$ e' h7 J6 C- c
print(li.pop(1))6 \7 @+ j1 \& V4 {' D, e* ~
print(li)
3 u, a. g9 U( _6 A0 ]; {
" z4 d3 F8 Z; V+ x0 F8 v9 Meric
0 `" `, \) l9 j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 z3 ^' E3 b/ A* \7 }4 Xdel li[1:]$ Q4 g4 A, I7 L
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)) W* j. }' z4 l4 \8 H, P& r
li = ['alex', 'eric', 'rain']/ `" B( X& ~# ^  l& T# X% R
for k,v in enumerate(li,1):& I3 w6 ]8 G; ?) K" e
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 v9 j, K( V; H" X
a. 请输出 “Kelly”
4 ~. p; H5 U9 O9 O- @/ Nli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ b! e' C0 F$ C; i
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 |. y7 \- ?: d+ mli[2][2]='ALL'
4 \9 G* z7 h" x) N9 i" f: Eprint(li), c$ e' L  O7 q: @) n
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; ?) P: [. g9 Q( Y9 H0 B6 N8 za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
1 C! ~6 q: ]: N+ L* R- Vprint(len(tu))
1 P' _1 ^5 B- ^! O& V4 L) g3 q. Bb. 获取元组的第 2 个元素，并输出/ f1 t. B$ ~; y4 V  H0 h
print(tu[1])
/ @2 O8 c% U1 r' a. v" N; M& ye. 请使用 for、len、range 输出元组的索引
; h. D! J. A# o8 K  }& A+ }for i in range(len(tu)) :
$ b8 O2 g, H4 G7 M print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
! R. q1 g4 I! A3 h" d4 U; k( ^; tfor k,v in enumerate(tu,10) :' Z& U0 f7 I- [% q' C$ K$ b
print(k,v)
3 ~( q: T& s0 T10 alex
' q: |0 D1 [4 C! L0 O4 n) n11 eric
& F. `. S6 J7 \$ N! Z% K6 S' Z- ~12 rain
1 g) w0 L9 L: o6 ]) u, B# m
5 ]! Q* y+ V' A; b! z# jfor k in enumerate(tu,10) :* B5 y0 \$ V8 G' s! r5 @
print(k)
' g* s' A6 |, X5 A# Q% m6 q  u(10, 'alex')
5 p" R1 a/ z! H(11, 'eric')
# P7 w  I8 j2 j(12, 'rain')
* ~; @; E2 O7 d: F" l; Y
- I1 c! D: D. p$ K- H  L) U, V( g( K
25、有如下变量，请实现要求的功能' d" Y7 `4 Q0 j9 r
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
; J/ u; c6 d" s" H/ Z
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 X  H, _6 r% x; A% t6 ~tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])$ n& s' F, j! ^
res=tu[1][2]['k2'].append('seven')7 N6 V. w5 X  D8 C5 O2 m  w

# R" G$ b0 {2 f/ f' {# W4 hprint(tu)
2 Q1 V% P$ k. B26、字典
2 ]9 V. S" h" ]dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
! [* ~( `; S+ d+ g print(i)b. 请循环输出所有的 value; t: c' D% p/ N7 E% Z  Y
for i in dic:5 G# `% q% [7 z5 x
print(dic)
& @4 j; S* z8 Yc. 请循环输出所有的 key 和 valuefor i in dic:. u1 S& q+ ?! X$ }2 v& X" r
print(i,dic)
& S: N1 d9 X' Ld. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典/ c, Z9 L" {: v
dic['k4']='v4'6 [5 _: m/ M! o3 N
print(dic)& f' \2 o* ]* [2 G: l
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! K0 p8 }, T# W
dic['k1']='alex'
; g. V& r' \8 A$ C, `- N+ [print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典% _' ]6 g  J* {& g- [3 ?! M0 W/ _
dic['k3'].append(44)
, f9 Y8 H7 D8 q9 H  |print(dic)
" ^0 m  v2 I& {. x$ M) ?8 i; j3 t1 v5 \& ^8 e
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典4 G- f/ ~! G: X/ d
dic['k3'].insert(0,44)2 O2 g7 r. _, r8 \7 H- F7 V; E5 D
print(dic)
+ ^5 n( Q/ ]9 {2 m; S27、转换3 T) o( n% k; D2 $ _$ \& ^
a. 将字符串 s = "alex" 转换成列表  s = "alex"
, C! C: y2 k; \- Y7 L* w# ]
  ?. J" k6 @/ o5 a  X1 ?- o  n7 iprint(list(s))b. 将字符串 s = "alex" 转换成元祖6 N, n+ N- A; c+ |5 T
s = "alex"
  d" i3 f4 f2 ^. Xprint(tuple(s))4 A6 v6 |( j. F& y& O8 N+ I

/ x' g6 X9 H2 F/ $ o: Cb. 将列表 li = ["alex", "seven"] 转换成元组
5 A! O: J/ }0 z" P: {: u% l; ?li = ["alex", "seven"]6 ?( j" Y' S+ w
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; N6 j+ n$ c- M9 B# N+ X8 ltu = ('Alex', "seven")
, x) H8 ^+ b( \* \" lli=list(tu)
* V, G4 F* b0 i9 Zprint(li); v, ^% [0 p& y( m

# [! F& [$ t- |3 N2 [7 ^; F8 Z4 @1 G5 y
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" x$ y5 v* o6 c
; U! @' u6 l' a4 [' p
dic={}
2 R* j" {! Y6 e8 I# D% c$ h1 Ofor k,v in enumerate(li,10) :----li要放在前面，序号放在后面" G! ]+ P0 {6 C1 e6 s  b
dic[k]=v
9 C9 }, d- ?8 F3 U1 s/ c6 o print(dic)27、转码n = "老男孩"# `& ~4 O4 |6 `
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
7 a2 k* E; e; T5 O4 V! g, X9 k% la=n.encode('utf-8') % \# i; a  c4 S
print(a). J$ _" Y; Z0 @8 F; x3 n0 C
b=a.decode('utf-8')
) U2 Q# C6 Z  V$ H) N0 V6 z" jprint(b)# I+ s& D: d  S. R
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
0 a7 V8 _3 ?5 t/ t0 ?print(a)( Z$ _! H' f. c
b=a.decode('gbk')3 _0 N+ J) k' h
print(b)28、求 1-100 内的所有数的和: F0 A5 g. A8 }  ^
count=12 B; I: e# Q  W" J* ^
sum=0# ], B2 _6 Z2 q' g2 D
for i in range(100) :. l# O! o& `- c  j
sum=sum+count5 E0 u) l) Q; g0 a! K' y4 ^8 k$ h* s4 [
count+=18 b! u' Z* h8 V; W
print(sum)* H" F* g$ T' X5 {, T1 B! H" s
/ |( g9 B' G  b0 e9 F4 J
count=1
5 h: m6 D/ @* z' N0 {sum=0% x( h& J# }# |
while count<=100 :
, Q7 s# r. L/ x' b sum+=count
; T* ]- n  N  r! ~ count+=1+ _0 s1 [* z7 ]9 i  }$ }: f
print(sum)29、元素分类
) _6 S6 K# d, J( q有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
" {9 q" m7 }3 F5 x1 M* {将小于 66 的值保存至第二个 key 的值中。
, I" ^' t' }) j5 H8 [; X4 f" F即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}/ e' a. J( v6 ]5 U
li=[11,22,33,44,55,66,77,88,99,90]
, d. f; s% k0 |# Z1 vdic1={
/ ]# W% R: Y! ?/ G 'max':[],1 ~9 q$ Y* [0 g4 c
'min':[]
' K* t( w+ w/ K. K; L$ f" p}
4 g, ]$ ~4 V5 B5 Afor i in li :2 A# s! a( a* @0 o) @2 t" o: |
if i <66 :
* M6 o' U! n; o% v' y       dic1['min'].append(i)0 R! O2 w# g% v4 o0 O$ D
else:" V( t8 D$ G7 q* l* d
      dic1['max'].append(i)
+ F+ L# w' p: P0 Q9 x$ i, qprint(dic1)
8 S: m  Q) X8 T7 H) @* t) e9 E& s
: A9 Y. S9 b! }! e% y7 z- G, Y" r4 t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
# [' x. d1 l" v: v# o

Python基础知识汇总

主题推荐