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、写代码
* a5 d; ^' `0 ?& U: L* w5 W) ba.实现用户输入用户名和密码，当用户名为 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) :
0 _% M  W) g( i4 P6 l9 J$ k name = input('name:').strip()
# A+ G" X. `+ d( H, W" X  J% _ pwd = input('pwd：').strip()
4 Z/ q6 U7 y7 q  `' z8 _* w/ a8 v  F4 y8 ~4 K- Z! K# D
if name=='seven' and pwd=='123' :  ^( y3 D  x: ?7 P0 D2 F& f8 H- v
      print('ok')4 ~. f- @: V) a1 q+ F
else:/ O5 v0 ~' B4 b0 t! s
      print('error')+ L+ h1 {! y; g/ N: J1 ~4 n4 ~( a
      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)  :+ J. S4 i" u6 Q3 a- G- p
name = input('name: '); N/ F+ _# L% n: P( E6 q$ v) a3 d
pwd = input('pwd: ')1 X$ M; v; G! g' T
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':% Z" [. l5 C- l9 u
      print('ok')
) r" O" r0 @0 u" S3 I' d else :
( ]  r- \. w! M( A       print('error')
5 y! z  u6 t3 \/ m       count+=111、写代码
" c. N& l- ~; u- }. T) h2 {/ Xa. 使用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) :
* ^( E) z, S$ h: B% P; I if i %2 != 0 :7 n) h! H1 M* j6 W  [
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :) _3 \/ u; E. H% K9 e
if i %2 == 0:
7 d% w- C, i4 E, F3 @1 W       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"1 y) W/ v/ b/ t4 b. `
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)3 s9 ]% A4 e0 {
for i in name:2 C- Q# L! r6 X& r- K, q* N
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain' K8 \$ v( w+ l9 Y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
0 F' y( Z9 v2 E1 gprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    " |* y6 T5 Z# Y7 g- _3 z4 d& c
print(li)
3 F; A2 N- b; C; m4 P2 z+ j ['alex', 'eric', 'rain', 'seven']8 B5 U8 a4 N5 w  c+ g7 n0 b
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 m) e$ ^# J  V' }5 S, Z8 Aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')/ N3 ~0 _  |5 c( F' b& |
print(li)
% _3 M% J. U4 B8 a5 \' o2 r# A6 k  He. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']0 I, i! B' K7 W
li.pop(1)
( E* l, L+ s* m% s- vprint(li) ['alex', 'rain']
( t6 @: J) ]* T指名道姓的删除li = ['alex', 'eric', 'rain']2 W/ A! Z, R. Y5 l- W: E2 t% G
li.remove('alex')3 _7 r# e) ~7 j/ w5 P( ^
print(li)
! r- G$ W7 f) \+ If. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']& z- X5 K. Y, q9 b: w4 Q
print(li.pop(1)), K3 d, ]+ ~7 ]2 g4 a7 U
print(li)
1 ?% r2 T. a9 k! Z3 s0 B3 d/ ]& n7 L$ q# Z. v" J6 r
eric7 j8 F1 N! D9 ~/ V2 w4 p) Y
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
( J$ V$ ~2 ?! f9 F: j! _8 ]del li[1:]
- I8 m- S  U& A; P( Y' F8 Wprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( a7 s: h$ k+ E1 Oli = ['alex', 'eric', 'rain']% u7 v+ h; r3 f2 N5 J9 M0 V7 k
for k,v in enumerate(li,1):
9 s0 k0 c" z7 _' l7 h2 B# b" ^ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& h$ X) |/ ?  O8 J
a. 请输出 “Kelly”
. e' s( A5 ?: v! }, a3 {( qli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 g2 r7 e, O4 w; P3 J0 M# j8 B
print(li[2][1][1])* `& k/ d/ P  Y2 D1 z9 t
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& u  P; }: w- E8 U$ \li[2][2]='ALL'; h1 E1 t& S( h+ o
print(li)/ s6 r7 e3 Y% u8 [1 @* x9 S& [, |
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'): v* k! L7 N: Z+ [2 `. k
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: T' F3 m* q9 `9 xprint(len(tu))+ ]: o. e# X- p1 ~  P! @
b. 获取元组的第 2 个元素，并输出
* t) n+ E  k6 |+ [$ Xprint(tu[1])
( L; k, V8 i( Oe. 请使用 for、len、range 输出元组的索引4 R+ ~: E( j1 f
for i in range(len(tu)) :
. ?( a. G1 b& T7 Q/ K5 ^. N' O) t' r print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 n* _6 K) B% F4 ^( d
for k,v in enumerate(tu,10) :
, K8 `/ S+ L7 t6 b% {" \2 ~: Q print(k,v)3 e6 N# [7 P2 T* I
10 alex6 D) S6 q  I+ g5 v
11 eric
; A, y3 V# _5 s! J$ L3 Q, x8 s0 m12 rain- ~7 ?; [: c+ V+ h' C

1 u0 f0 @  j' b9 L1 z" Cfor k in enumerate(tu,10) :; {$ u: I% G! W1 d
print(k)
& V' m- R4 V5 z3 D(10, 'alex')
. z- K- K2 U% G; Q- b(11, 'eric')
7 _; `6 c# D( |2 D4 Z(12, 'rain')$ B" z0 b" Q, u0 S5 _' `
* S# i2 ^: j8 M6 w

9 B5 \0 a/ |* A6 X2 C5 R25、有如下变量，请实现要求的功能
" W: S& K& Y. |! d7 stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

& S( Z/ s8 M2 y. m; S9 d) {d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
2 X, m4 z/ u# R! D3 p; c6 Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
' p2 n9 P# L# @6 @! p1 o+ @( vres=tu[1][2]['k2'].append('seven')
  V+ [: b' N. v2 I! Y
9 s+ N4 J% U! o  a$ Mprint(tu). a$ W8 W/ p7 a/ P( m. h: w# x& D
26、字典
4 a, U# ~  m8 j' ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:* M" ^1 i* |6 h' T0 r9 b3 w
print(i)b. 请循环输出所有的 value
# T0 _" J. q# j( |1 Nfor i in dic:  q( [! n4 B! \: p) ^' ?$ P5 ?4 i
print(dic)
4 Q- K! L$ @7 h7 U% ?c. 请循环输出所有的 key 和 valuefor i in dic:
" {8 A6 T, C8 E" v& V0 Sprint(i,dic)7 L5 ]" S! \0 a8 x3 D) w# r
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典% |" c: J. e% B# p0 l  Q4 f0 O- t6 o2 S
dic['k4']='v4'
, c0 E  D, L3 \* b. U# {: fprint(dic)  K) |9 h) A- |' ~' I% Y! I
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
$ A2 N) |( ^/ m& ?dic['k1']='alex'
, A5 e8 s2 o* ?4 C8 {6 v* U0 H4 W) Aprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* T: m+ D7 V- Z8 z6 F. Cdic['k3'].append(44)
5 d/ [; t) I# M7 q  q, n' X5 kprint(dic)5 i% G! L6 _: ?, y3 @

6 s- d& b) _! b. g) W) H% y8 ]- ig. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典( [9 k9 o+ }9 d. y
dic['k3'].insert(0,44)8 G- i# h+ k8 g+ W; J! U9 `. T
print(dic)
' m; l0 _3 p% P) U4 w27、转换
, t2 \$ f& P# ga. 将字符串 s = "alex" 转换成列表  s = "alex"
- L+ G" p2 i0 a6 z. W  K2 ^& s$ y+ ^6 N
print(list(s))b. 将字符串 s = "alex" 转换成元祖
( V; V  t* @, N% [' O: @5 |s = "alex"6 w( k* O+ a, R, R- w, x* H4 X  q
print(tuple(s))( ?5 n5 _+ ^. ?) t( `
, _, X' ^! V; N" W
b. 将列表 li = ["alex", "seven"] 转换成元组
- o: ?  c* ]3 o+ m, W$ k0 Pli = ["alex", "seven"]) q' l) K. d, `' S# d
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
7 D* l* \- j/ h  t9 \tu = ('Alex', "seven")9 C" h8 F4 s2 ?2 S0 q. l6 L0 L7 ]9 r5 i  z- a
li=list(tu)
* V. _  [3 L+ I5 f- |print(li)
' L3 v2 i" t0 z: c
* k( Z1 ^- \$ a6 }' @7 C, d8 z9 R1 k: h% x! Q5 s9 C" A
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
7 S5 Z2 Q  D0 U% G3 r
( j$ U8 m" }. K" Tdic={}
. E- {& T) F' Q& |. s- A' }" dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
; j( X3 E* T; y8 a& f: e* [) f dic[k]=v
% ]* T2 X1 p: D8 _) I# x% l8 I print(dic)27、转码n = "老男孩"
/ |3 E: E" v. y( ia. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! j: H, Y" E8 [1 ta=n.encode('utf-8')
6 C5 ]( B1 j4 W6 \, Vprint(a)
* ?& f6 ~; h! F# L% @8 v- w8 @b=a.decode('utf-8')6 z" R6 z3 Y9 P6 C  ~8 @5 l
print(b)8 `/ x7 X& `9 d, P& {3 V
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 v; n/ ^1 P* O, `0 A
print(a)0 I5 E% B7 ]& O% K3 l8 I3 n# E
b=a.decode('gbk')
6 `( e; i  J  h7 p- \# ?print(b)28、求 1-100 内的所有数的和
# y" V3 _' R2 W* D: p7 I! y% {count=1( E3 Q7 p( x7 S- }
sum=0
' M5 m( x( q# v7 ?% U. y$ m9 rfor i in range(100) :
' o* {% S: V* i8 J sum=sum+count4 D0 O, C+ a! b' h- T
count+=1
0 k) B3 k1 j$ D# dprint(sum)& Y: e7 Z- y! q/ Y
! P+ h! G0 X8 b1 R2 h
count=1; v; \' [% X: D1 b+ [) p
sum=0
/ D8 }7 I1 G" d: G  u" ~while count<=100 :0 Q* i+ e* i( n2 H9 `0 l2 E
sum+=count
, [! F. ~1 K$ W3 E) |. l& R count+=12 p2 |* w" L' r: y
print(sum)29、元素分类
; {, x9 k) i0 e( k% Q- S0 j有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
( A, M1 c2 b3 T$ O9 a将小于 66 的值保存至第二个 key 的值中。
7 B7 [7 Z% T3 ?4 [即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 O( ?/ G; a# _& Q7 e8 `: ^li=[11,22,33,44,55,66,77,88,99,90]
) Y# j! d" ~' ]dic1={" o3 X: N$ |/ O+ ^  o. U/ x; U# K
'max':[],$ l$ J1 U: V2 x+ f) U8 ]  e8 A
'min':[], q, R3 _/ s5 d3 U# ^
}1 q* U' [5 e+ Q* C0 r- w1 [
for i in li :
6 l5 l2 [) z$ ]3 K: e$ r if i <66 :2 l* k4 j/ f) N) A0 i/ L0 T7 |
      dic1['min'].append(i)
* A( |3 P+ N9 r: s else:
$ h% `2 D0 B+ Z* _. b! ~       dic1['max'].append(i)8 N/ P6 L9 {# u5 x1 H1 H
print(dic1)- W) I! T5 J* B5 s% }

+ ~  \: I/ V0 j7 k---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}: F4 W7 ?& M  Q+ y  w' F

Python基础知识汇总

主题推荐