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、写代码! K+ a: {' W0 M* ~4 @: Q8 ^
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) z9 J# e! c2 e; f. s
name = input('name:').strip()3 Z& W& h$ y! n
pwd = input('pwd：').strip(); p+ e4 v( M: F5 V

2 r, o: }! z% G if name=='seven' and pwd=='123' :! t: n2 p/ U4 I4 S9 _* X; n7 l
      print('ok')! |8 I/ Y" g; H
else:
0 R9 T& f: G% ]       print('error')
! E% Z' ]4 P* {, I% u; E, f: V       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)  :
! V0 V5 h5 x" \6 z5 y) } name = input('name: ')0 b  E. Z, n6 Y# U; ]+ C
pwd = input('pwd: ')6 Q+ ~* q- F; j7 _: u% D0 C
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':: Q2 [0 l  U1 t" S- Y( K- D
      print('ok')1 T2 K! m' p* e- L1 P7 x) ]
else :) D+ {3 H; H6 n+ X% c
      print('error')" b7 `9 N  p7 x: V6 {
      count+=111、写代码
' K# j5 h" H0 ?! h* o" N; f, ia. 使用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) :
) c9 u/ ^" @# l  v* t if i %2 != 0 :* M( l1 z6 W7 {! g6 q9 G- z
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
) B1 }- p/ D, g# W9 l4 ~' L if i %2 == 0:; t" c1 ?$ \* ]8 R$ @: G* V8 h) P6 G8 x
      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"
8 q) k" a0 N+ ~3 H3 }- z, @4 fa. 移除 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)2 L. _9 c2 a3 K+ F$ b  _1 j7 a0 s
for i in name:  q/ t% u6 T0 t- p
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
. j/ c( }: N! r6 W/ n4 o' {/ v22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
/ ~* E3 C+ T$ x( c# zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    . D' ^9 Y! K/ I' w8 t% v$ P
print(li)2 B) P9 ~2 P" {+ T) m9 M( P
['alex', 'eric', 'rain', 'seven']
7 T% s7 \. q4 O8 E4 Pc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
" e# ^7 p% B/ K2 a! g" Cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')3 P- A2 C( w; y7 q
print(li)' V% V7 ^7 x3 ], _* C' @/ ^
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: d* p) J1 f1 O) a0 S2 u1 xli.pop(1)4 m! V5 w8 u9 a) g+ L* N
print(li) ['alex', 'rain']
+ G( [2 ]$ k* b6 y4 y指名道姓的删除li = ['alex', 'eric', 'rain']
1 C5 `! M; X! N! tli.remove('alex')8 _, ~$ N/ X6 c; O) ~
print(li)% e; m  K1 P8 F* e
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
* o* g# X* B9 Kprint(li.pop(1))% S' T/ g# k, v# J( }
print(li)7 g- {$ `3 y7 U8 A, y4 S
' W& Q- r) ^, }, t, V3 u( ^2 p
eric% C+ N' b2 `6 S' j% c# v$ E
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& F5 }) k5 N. i& f# Qdel li[1:]
. |+ @* w. P' J6 R4 ^print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)3 y: p6 [6 {; A: T) q, }, T- c7 |
li = ['alex', 'eric', 'rain']( G) q* _! r8 o" K1 Y
for k,v in enumerate(li,1):
3 e( L; F8 T  `( O( k print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 ~4 y1 \0 e1 _' E* `a. 请输出 “Kelly”2 f5 N. i+ V4 U, w: |1 s$ `: z: n
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 T9 u6 ~3 H6 ~1 v0 C+ {- j+ T6 z
print(li[2][1][1])
  T+ t& e% H/ eb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( ^3 h6 _' E$ Y" k: G+ mli[2][2]='ALL'8 ]" ^3 ~( V* n  S6 a
print(li)
2 J7 s& |3 h) |24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 y% Z- q5 _0 \; ra. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
3 X3 \2 e0 i2 N0 @7 o% nprint(len(tu))" \- _: m; E5 v7 j) v
b. 获取元组的第 2 个元素，并输出+ ~' |; ~4 C8 b; E, @" ]% I- U
print(tu[1])
" w7 `3 Q4 y: U  w4 j) O0 ne. 请使用 for、len、range 输出元组的索引
. _& j" e5 k" O. d( p8 ^! \for i in range(len(tu)) :
+ M8 L/ u8 A8 D+ S3 [  N/ N7 N5 y8 X print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)& w: j# n7 X: ~; k/ l
for k,v in enumerate(tu,10) :
' i+ }2 Z, Q" w print(k,v)" X. ~7 Z4 E0 R* U2 M
10 alex9 z0 Z. M- q% t/ A8 y9 v6 k
11 eric
  z4 s, Y6 i, ~' Y) ?5 R0 y12 rain
# f: l, p, m* ?9 r1 ?& W7 B2 h( e% g. t6 O  A3 ^
for k in enumerate(tu,10) :9 K1 ]& D9 _8 z& s7 ~* J
print(k)
! Y& C& Y9 R6 f$ B8 s(10, 'alex'). T# L/ {) s: z! G: J
(11, 'eric')- m1 @! d- @6 w7 R3 I" ^) H0 w. h
(12, 'rain')' o. S9 Y' ]6 t% ~1 E8 T
, p1 @) g, @% U0 x# K- \# n. V' k8 \

4 V. N# g0 l: j7 W' Z; y25、有如下变量，请实现要求的功能% j# _' l2 d9 y( ^
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
% e+ L/ g/ K  s+ V5 `
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以' |. N3 D" H3 R+ Q8 B
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]), k' t/ i1 C! Y7 j5 Z
res=tu[1][2]['k2'].append('seven')
4 t3 B* s7 M7 N5 ^: o5 y  U2 h$ S) h4 Z5 C- y3 p) I
print(tu)& [5 C% V  L) l  V: l
26、字典" |. d) }2 |; e0 M' n
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:2 ^( G/ u4 X, q/ ?  I, O; W8 ~  r
print(i)b. 请循环输出所有的 value, b7 z! m" J: X$ m3 W' f7 e
for i in dic:
6 [. M5 x7 u4 u. c5 ?# G8 N print(dic)6 C" [  Z+ z" n2 D" R  L7 h
c. 请循环输出所有的 key 和 valuefor i in dic:- o9 w' i0 A$ m9 K
print(i,dic)
1 m1 r( e0 z, x% {3 P# {d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典  K! h& v+ Y* q1 V4 a, k2 G' w
dic['k4']='v4'
+ Q6 L3 W, |1 Q' N/ ?6 u* X& gprint(dic)# _/ {4 _3 P) C! b; l. k* z
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 S5 x: K4 v/ h4 N( h0 l
dic['k1']='alex'
. k3 a' p' u' Cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典) N( `8 V. d% N' T& o
dic['k3'].append(44)8 {$ E, G9 g5 i# r( F" @
print(dic)
4 p! L' e/ e4 S+ X/ N9 L
2 P) B6 l1 `0 z6 vg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典! x% r7 ]6 w: B
dic['k3'].insert(0,44)" I! j. v" f& T& i# i. d3 S0 ~( S
print(dic)
/ a4 h: t6 c2 b3 ~- v# V, c27、转换
/ ^) U4 ?  t1 \$ Ca. 将字符串 s = "alex" 转换成列表  s = "alex"# u. d5 h" q6 I! S: r- Y

" E5 h- T3 E1 j! A, Qprint(list(s))b. 将字符串 s = "alex" 转换成元祖
: a; N: |6 E5 O, cs = "alex"7 R% U+ E- p; }( Z( n
print(tuple(s))8 A7 @+ y4 H' `8 F0 U

% p9 x- ?9 [; y# E$ e2 cb. 将列表 li = ["alex", "seven"] 转换成元组" i# ~1 @' E2 L; k7 B
li = ["alex", "seven"]0 N* v3 X/ @/ ^0 K% b
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
+ ]( A+ w2 J/ Dtu = ('Alex', "seven")
  D5 V6 T; ]1 ]2 h1 Gli=list(tu)
; X  _# F- c" L3 C$ b3 O3 ~' I# rprint(li)1 C9 ^# f0 C$ a5 c
5 Q$ K$ n! h& @- f& Q3 {
, D4 s) i9 t4 ]
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增: m( ^' e8 }0 `' c4 L# @  y' b4 @# [

% Q) g- y. ?" Z+ S: X6 E' kdic={}
. C# Z1 E1 O5 v( X6 S  Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
4 d% |8 g/ e; g# V& C dic[k]=v
5 G9 d/ W' i: N2 d print(dic)27、转码n = "老男孩"
/ d: R, n, b: A9 @a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 H6 P6 D7 \, V6 z, k6 ^a=n.encode('utf-8') ' ~7 C: M+ C7 `4 l/ g; x, v
print(a)
# B  ?  c% b4 B/ V$ N6 j0 Q' _& bb=a.decode('utf-8')% l# n. P% P$ {, Q0 V  P# E
print(b)
4 r* e; Z9 n/ R( q3 nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, }8 X& O* L5 h6 A9 [' e7 x$ B3 [print(a)
+ N/ G# k" V* K  p5 l* Ub=a.decode('gbk')/ k. l! S& B3 F& ?6 d- n7 a
print(b)28、求 1-100 内的所有数的和
9 I2 k) f+ ?% v) a$ V; c8 K- _7 Y/ qcount=1, ^7 L. V* d% M3 a( l1 P; c
sum=08 L; G3 l2 P  p3 E, Q6 _0 A
for i in range(100) :
( d7 D. K( Y) t% J9 ~5 D' C  `0 R sum=sum+count
# q  Q  R! I: w) V count+=1
9 g+ K# u  ?# O5 lprint(sum)
" y8 N' ?% r% o; w
1 ?/ a( g! p) R" Wcount=1
1 ~* J* Q7 B# S2 y; Nsum=07 d9 M& M4 a& c7 ]
while count<=100 :
! E( l" {7 W/ E) i sum+=count
/ k; F- t& j# T5 x. ~( s count+=17 E" \0 m$ J4 ^) a6 Z# `
print(sum)29、元素分类+ |8 m% F3 |2 u( u6 Y6 x4 M' P
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
4 n! S2 M0 E' N9 j将小于 66 的值保存至第二个 key 的值中。
3 E1 S, M3 c. E& l2 |8 H* f$ G: ?- S' K即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
* b. H. m# ^& Z$ G) i" uli=[11,22,33,44,55,66,77,88,99,90]
, q: r. D8 O; }. Cdic1={" O' t& w3 B* u- `( V6 C1 {2 i
'max':[],
! v/ A& \8 Y3 D 'min':[]6 R! E) d8 b) O- ~, ^
}5 q* q! E! e8 R  g% |& s& B
for i in li :
  q* U0 U- {; T' \3 x9 \7 m if i <66 :! o. ?) x4 T: F8 y$ |+ \
      dic1['min'].append(i)5 {2 [# D1 S( z! E% L1 W
else:
. P" @9 r. A9 A% w) }, W       dic1['max'].append(i)
2 Q6 q! h# _% K8 v$ Nprint(dic1)
8 A0 d4 V% [( [8 O$ Y7 ~* Z8 p8 ~: H' S$ H  P# m% Q" I
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
- d6 F5 f! ^+ O5 O$ a; X" T3 m

Python基础知识汇总

主题推荐