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、写代码
4 D9 }. f8 c7 \/ ]: g/ h1 Ya.实现用户输入用户名和密码，当用户名为 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) :) j4 C/ q( ^! v% O, I2 f+ L
name = input('name:').strip()2 u7 V2 S2 K- S# l" j+ ]1 W
pwd = input('pwd：').strip()
" M6 t: s0 J# a+ r4 H- _0 c) s+ h) o; h
if name=='seven' and pwd=='123' :
/ M0 w5 [# H9 f% Q+ d% C; ^8 B9 H2 m       print('ok')
8 @& K3 c( B, e4 X else:
. `2 U  @- P9 @- g       print('error')0 D8 |3 l/ H4 r$ e( [
      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)  :
9 {* C, _  l, j, {7 r7 U5 { name = input('name: ')
: G% A0 l3 X# K4 d: X1 @ pwd = input('pwd: ')1 X2 B1 n$ ?7 \( @
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':7 r6 k" N6 b9 ?- I& \$ U+ K0 f
      print('ok'); n! }0 J3 G9 M3 H$ w7 C% l
else :
1 z; {2 L* U  Z2 h; S& H9 `       print('error')
( A( e7 N' }& i       count+=111、写代码
9 O. N8 u: z5 Q  M2 [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) :2 q8 c. o# z, `0 ?/ Z; E
if i %2 != 0 :! g: ~: r# g; m0 Q& ?  u
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
4 v) q8 J2 e3 S/ m5 j if i %2 == 0:
3 s/ u" [* ~/ |$ q# c! W1 o       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"/ m* m- F+ V4 K) r. o  G. p' l) f
a. 移除 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)  W: z5 G( \" L; a  ~
for i in name:
; b8 m& X' D8 K' [: n: o) A print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
* x6 b$ I- G6 `6 w' O2 _22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
: Y% B$ v3 u( P  z" Pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    4 H$ w9 g; l" F' z( m. r7 d6 Y- \& v9 p
print(li)( \" Y; Y) C" R, r/ I5 ^1 l
['alex', 'eric', 'rain', 'seven']0 H$ [6 f; {7 c
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
  K, z- S: P6 S  U1 {print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 q% e$ a+ {/ b8 z2 ^print(li)1 {' ^9 y0 y1 K! w/ x) R
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']# |$ }) f# K5 u* p$ x2 p" c' ^
li.pop(1)9 r2 j) z0 C! g5 Z( G
print(li) ['alex', 'rain']
. s! o: ?7 ^' {$ M4 n% m指名道姓的删除li = ['alex', 'eric', 'rain']
: A  u/ r( a3 Q5 {, ?7 I7 L; Y9 u; ~li.remove('alex'); i; V  {6 ^1 V' `/ ?* ~
print(li)
, \8 ?: @; ~. V' l* gf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 f1 B) l4 j" E' A$ Cprint(li.pop(1))1 B/ ^0 P1 i  u0 a
print(li)% ^4 u( O3 x1 }( P! H* W# j6 \/ S; W

: P5 L6 m  q3 c4 ~% O0 Xeric
/ ~1 n1 h9 |) G9 c5 v['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, ~% m0 I( N# U4 I# v4 q8 [% _del li[1:]8 Z( \- H5 Z, t7 a: l3 _
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始), `6 C  x' w  p" x) ^9 y' s7 Z
li = ['alex', 'eric', 'rain']
1 }2 H1 D! c2 [" K) n4 kfor k,v in enumerate(li,1):/ |, F" T' S! v. X& m
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]. N6 i8 E' f) P5 V5 u
a. 请输出 “Kelly”
, m0 p' A8 z0 G. hli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& }8 B. {$ l* _9 D, j# c, [" A* B
print(li[2][1][1])
. Z3 I5 {7 f8 G( X# M+ Ib. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 t9 C$ [% ~5 A& dli[2][2]='ALL'! H6 I9 o6 I3 r( e3 h) H+ Q- R
print(li)
, F* n+ @4 M# {) K, H9 [3 b% r  w24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
+ o( {2 R/ S& V" s, Z' ua. 计算元组长度并输出tu = ('alex', 'eric', 'rain')- [+ d! q: k: I# c& f
print(len(tu))
  B! T% c9 @% |b. 获取元组的第 2 个元素，并输出" \5 M( z1 z9 i9 y
print(tu[1])
* y* b4 [  {' Z! Ae. 请使用 for、len、range 输出元组的索引+ Q% m8 a' K; n2 [3 y; T
for i in range(len(tu)) :
8 e+ F1 {$ D! P1 }% B" a  {) G: ~% U print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, U" `  X3 `5 D+ t/ D- v+ U& M1 }for k,v in enumerate(tu,10) :
+ Z1 n$ M( b& G! z* z# {; V" T" i print(k,v)/ Z3 e/ _7 ]1 f3 {
10 alex
8 G7 }4 E  H. J3 b11 eric
1 L2 S; Q' O& i) X1 c1 r4 v12 rain, ]% Y) p) j- ~$ m4 s

, ]$ w& I% K; C! ]for k in enumerate(tu,10) :3 E9 b# Q6 y( I4 {' Y
print(k)
8 e; I, u. b) F" G0 F: E# ^(10, 'alex')
; j4 W( y1 _, ^  O% R/ `4 `8 ~(11, 'eric')1 y4 r; m. t* E- x4 k  I
(12, 'rain')
) q0 t% H8 p2 u+ u- X' l- o' m& u8 r  w8 m& ~6 B- }
( r/ v7 E- V. U. v' |
25、有如下变量，请实现要求的功能
( D7 D% o4 `- m$ Y; `& otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

3 ?5 u6 M. W- {; m3 P! Nd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 t) m, h" a8 L( H5 X9 Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% n/ S& t8 h$ r& k5 T; ]res=tu[1][2]['k2'].append('seven')
5 C2 X, I2 L7 k0 F
6 j, q6 B8 ~; }  ?2 uprint(tu)
+ M' ?& W- k' r- e  l* E/ s26、字典
' Q1 u" R: Q( H9 Ydic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:, v6 F, F, G/ E& c0 w0 t
print(i)b. 请循环输出所有的 value$ r7 {. {0 |9 j  p
for i in dic:
# r7 f* K  i  T& V+ I print(dic): P+ a, d' G8 |$ ?% M
c. 请循环输出所有的 key 和 valuefor i in dic:
# b1 Q- h/ f" H& b2 Qprint(i,dic)& w$ T% q9 J9 e7 l  }" T
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# t$ T+ G# b9 m, |; i: }: u' l
dic['k4']='v4', e: h- {0 G9 R4 }3 V; {: C
print(dic)
# \, J% n6 i6 z; b& U1 }" oe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: \# u( [  ]$ Q( C
dic['k1']='alex'& i  [2 i9 `' a$ t3 D4 L
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典! }0 z% O+ T. r- V
dic['k3'].append(44)0 m7 Y/ f' W( k' i$ S
print(dic)
3 {% {2 u& y! o3 ]7 j
/ b$ F, Z* m$ G- F$ Ug. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; R/ P0 w. Z6 c. M3 i4 jdic['k3'].insert(0,44)" e1 K5 g$ x. \3 u+ o1 A! ~7 V; m' d
print(dic)
4 q" V+ J! K) Z; b# A27、转换1 A4 o- ~8 {5 x9 u* M. H+ J$ h" U
a. 将字符串 s = "alex" 转换成列表  s = "alex"' S- G7 I$ K# z# E' k& A0 C2 w
/ e0 B3 z7 ~+ t$ W; ]
print(list(s))b. 将字符串 s = "alex" 转换成元祖
3 h2 b4 f$ b3 N5 [) L' w0 `0 bs = "alex"3 C  ]- L# u( e0 p( L
print(tuple(s))
: t. L! O5 _, D& X5 O* Z9 F; u/ k. T  h, Q% R$ N% n. t9 f# V6 B/ Q. P- C
b. 将列表 li = ["alex", "seven"] 转换成元组- e+ r) o9 w1 }3 c8 T# B
li = ["alex", "seven"]% Z% X# D, ^& |4 ]. r
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% v3 [& Y! m- [  C, c3 Gtu = ('Alex', "seven"), v0 {$ S$ {2 e, b# d% X) n8 J: _0 C
li=list(tu)
" J7 Z) Q3 N& Eprint(li)% ?+ p1 F) g, v% L! v: i/ n# J- Q
& P5 f! ?# @0 S

% D: p- `% Z. d& S' e( W. ld. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
8 O; J* O; p" i) b) V
0 P0 X! S4 X  u- F0 idic={}- l3 \: K3 |5 H8 \
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面' R" m" G8 {1 c* f( `1 e
dic[k]=v( ^6 f& |4 C( {1 d- q  M9 Q
print(dic)27、转码n = "老男孩"4 J; a5 {- X  z0 ~, s' L
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"& M+ v# v$ v- ^; x
a=n.encode('utf-8')
9 |( D+ u5 ~' @! q% _: hprint(a)
3 ^" A; v8 S7 B# xb=a.decode('utf-8')
/ @  l4 B. J# j4 U" tprint(b)
0 J& w2 Z! P' e  T) b  zb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')3 x* A! m4 Y- V' i# b% \0 a1 h
print(a)
& u3 [. }1 ^, }4 ?! db=a.decode('gbk')
6 f$ Z+ o) x& N+ s! W( o" s# Uprint(b)28、求 1-100 内的所有数的和
1 F3 F6 n5 h6 S6 Hcount=1
2 k# s- g5 m' @/ J2 O0 X% bsum=0$ B9 F) m6 W% F5 H( I" o- G
for i in range(100) :$ d+ f5 d* Q5 J2 C
sum=sum+count2 A9 b+ x4 u  F' ^) o7 J
count+=16 B8 t1 ?  z0 J0 E5 H1 E) S
print(sum)
* D2 u! p; h. A2 _+ |0 L7 r/ n; N7 T; z8 K
count=1
8 m; N5 I* X1 r  T( X8 c" isum=0& M! Q7 g& J& F3 y
while count<=100 :
/ P# l$ U' f; S1 ^# X. ^$ g& \ sum+=count' w) o) r- ~- O$ n4 y, k4 D
count+=13 C5 v" W9 r$ ^4 S
print(sum)29、元素分类4 F2 `- m6 P* y1 Q$ B
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
# H' X+ C4 b/ k. ^/ D. v将小于 66 的值保存至第二个 key 的值中。, Q+ _$ S! o! U7 l+ V- T
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}, ?$ K- v7 Y( H  W; g2 q% E
li=[11,22,33,44,55,66,77,88,99,90]
% b0 {3 L, ~5 E, h; u0 M/ Adic1={, S* g: _( e9 Y9 k: _
'max':[],2 n$ w/ m. L- [
'min':[]
1 \+ R& `6 }/ \; A2 \0 D}; M! v# [. q2 {/ |0 G$ z" ?% ^- G8 u
for i in li :
% ~6 v8 g5 j7 G8 Q0 D4 J" {, `5 P if i <66 :! `. ]+ N* h! s5 q0 Z  y+ |
      dic1['min'].append(i)! W1 E& r) O) j: o
else:
9 D* h2 x- T, f* S5 E7 U, [, |/ T+ \       dic1['max'].append(i)
6 D3 ~, I( E. I0 m+ @5 v6 qprint(dic1)
7 m, A- b+ r7 }$ ]; ?
. y- Q1 @" O, I3 _, l6 a---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}! q  J7 y& u5 Z: z

Python基础知识汇总

主题推荐

浏览过的版块