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、写代码8 x% r9 F' p/ T1 E+ I: E1 ?; b
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) :/ B: V  A7 A4 h" l3 T: c' V
name = input('name:').strip()* Q& g  Q% X  w2 B& J
pwd = input('pwd：').strip()
& f2 d5 }" m9 s3 o1 @) ]$ O0 y
4 d3 c. o( r8 B" n5 M) _ if name=='seven' and pwd=='123' :
0 m* S( C& b6 c6 p6 Q3 v9 U       print('ok')% d7 k& w. p, R) _7 d7 o
else:
8 Z) [. p9 s1 x# l4 `$ b4 g6 B/ ?* E       print('error')1 B" V0 T6 J8 j' u% J# C, 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)  :
8 H1 [9 F: e% y name = input('name: ')
- ]1 H1 K1 G& W' }1 t pwd = input('pwd: ')
- Y/ G# s7 `) l, K9 N6 u if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':% ^5 U$ H# \2 Q# P# Q
      print('ok')
8 n! T, P* m  c% X9 }. K else :& u3 V8 T* N; O1 I
      print('error')
: R7 w4 S5 k  ^: T       count+=111、写代码
$ P4 i1 j4 v1 R& s; d' ^  k$ za. 使用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) :
) u5 G+ O# X$ `8 H2 i" \& B if i %2 != 0 :2 ^! A) b+ E' S
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
; B9 t% s( |7 G if i %2 == 0:
- r6 J9 p/ ^, W. W1 A4 h3 t& z       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"
( h6 l5 ]! u  s: m; Ma. 移除 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)
6 G. j7 G4 f2 ^6 X) Q; Ffor i in name:, ~4 b  H" C& o
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain& u5 e5 n* [6 K4 Q0 h. v1 s
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']& b2 X9 x* }; j- a! Y- J
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    , b* S2 f1 t0 S- w! v& ?
print(li)
# v: ]4 U- r4 y ['alex', 'eric', 'rain', 'seven']6 p# Q2 E6 _( z
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')& B/ @. G! _- N2 B# x  i+ d
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 t! R1 ?  u1 \$ o6 q$ ]1 cprint(li)4 h* f! K) g; D
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: L% @- b$ @- |, J% [li.pop(1)  h" f8 N1 q& m  n7 Q, X
print(li) ['alex', 'rain']) k+ r9 k: N, \! Q" }: L+ t) D
指名道姓的删除li = ['alex', 'eric', 'rain']2 E# P( J; f. s# t  O
li.remove('alex')/ ?% Q/ o% ?7 B! `7 B* y0 d
print(li)
. c: J; }0 ]' a) U7 S+ K  }f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']) g% r+ D2 {5 Y3 a: G+ _- O
print(li.pop(1))
* j2 t  G0 ]4 K$ c3 R& |6 Hprint(li)) [( t+ P& p: E" n) `9 q

* b* O, t; M* m% c- D1 q4 Oeric
2 e" N" d$ G1 H7 C$ T/ s( d['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']1 O. v% Q* v# H$ x* t+ D( H
del li[1:]
8 h- s8 ^8 w! T- l& B2 Gprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)" k  z" O; e! d  c
li = ['alex', 'eric', 'rain']
. E/ H5 w( P6 _$ bfor k,v in enumerate(li,1):
" i: t/ ^2 l# o$ e6 @6 x print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]* U% d9 A7 ~/ O
a. 请输出 “Kelly”
3 X6 S# \) _( _! |; v" r& vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: C/ _- ~) t2 A8 D
print(li[2][1][1])
3 h; k4 {) D  X2 T2 h, x% wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”, B' N" f5 k  v# \8 M
li[2][2]='ALL'1 M0 q( V. [# s5 O
print(li)
8 U8 h/ y2 e1 r6 e. d( d24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# [2 ?2 {. k3 \7 t  y1 h+ P' ga. 计算元组长度并输出tu = ('alex', 'eric', 'rain')' A( T. a7 v) h- s; D% w& k
print(len(tu))
. C/ T# C8 H, E; G5 ?* db. 获取元组的第 2 个元素，并输出2 U% k8 S1 c9 k# c
print(tu[1])
" d! T0 |/ [7 B% B, b7 A! U0 me. 请使用 for、len、range 输出元组的索引
1 o9 H. i7 q7 [( y/ W7 o9 B: `! Ofor i in range(len(tu)) :
7 ]* z$ [; m) G/ g+ L+ t print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 O% v: N- Z# j, N, B: V5 T
for k,v in enumerate(tu,10) :
& d3 A* `+ w, P print(k,v)
+ n: ?; O. d. _% J1 x10 alex- j2 W5 x$ h8 m& X/ a( O& k
11 eric5 S5 r. A+ p4 v8 k8 S$ }
12 rain( a+ p+ }2 D! Y* W( Z2 G* i  K6 ?

% |$ f. s9 _' k- O( zfor k in enumerate(tu,10) :
9 K* Z9 D3 w, r) j: I. M% b* [ print(k)
1 N9 S3 g# {1 l4 L  S(10, 'alex')* `7 N. w; O9 S: D! y: D$ |+ ^+ {
(11, 'eric')
. W; _. l$ [' w8 ]( k( C(12, 'rain')9 |9 t/ a) a  k' Q

. j( _7 U% D% s+ g* U) R8 p% `% Y4 k
25、有如下变量，请实现要求的功能
' l# }0 R! w. q6 \8 q$ Z: F( u7 n( Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
" _6 v- Q1 ~6 @% b! s
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
( [1 {" h9 W( U1 Z' Dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
- K2 m0 s+ W6 [6 |" Nres=tu[1][2]['k2'].append('seven')
4 x! m! H8 L' N' q. K% t
/ y% I  D: h& m6 cprint(tu)
5 l- P  B! M( p; \$ k26、字典; _  q, E, I7 M3 A6 |- x2 Y1 i) O
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
- g' U  {: C. Y- A print(i)b. 请循环输出所有的 value: X0 S0 k( o" w/ C- I
for i in dic:0 ]# n! X# v- o" ]) V
print(dic): t$ T- J  N- z2 Q: ~
c. 请循环输出所有的 key 和 valuefor i in dic:
0 \' _5 Z: Y+ v1 sprint(i,dic)
- i7 U/ A( t, }& J$ R% hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
; T! y6 i3 G7 a% Z/ b. e( y5 Ydic['k4']='v4'2 \- ~, n9 l& Y2 s4 l; T+ V( h
print(dic)
# {- L% w* K; [9 O5 B# a4 |2 D' se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) B# G6 Y4 n9 `8 D& y4 U8 ndic['k1']='alex'
) i5 y) P9 G( ]; Eprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典) ~" q4 D3 V, e& X
dic['k3'].append(44)" N! x+ F+ N5 q& A" ?
print(dic)
$ v. _/ f( ?1 p% \; t& E' |
, d( o! I+ |: r, [9 @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典2 J2 o  \0 `; n- X/ o6 ?5 x  \
dic['k3'].insert(0,44)
# u# e5 K* T; W. B0 N) C% u' iprint(dic)' J/ b% @/ j, z' X
27、转换3 N; m, i8 R5 H) l5 ^" g1 d- R' H) }
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- s% I) d$ h! k4 \8 A: y1 ?: _& f' }; k8 C7 B( w! E
print(list(s))b. 将字符串 s = "alex" 转换成元祖
% i" {6 H2 s$ l% {s = "alex"9 ]' A1 A( S2 J4 V, z! {
print(tuple(s))
% R! w; G% t3 V4 y
9 a' ^' F: X. pb. 将列表 li = ["alex", "seven"] 转换成元组/ I0 U" v, U/ r
li = ["alex", "seven"]% b* x$ f/ F6 y' u6 m
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表* ~7 @7 V, t: _4 t7 a/ p8 X6 Y3 \
tu = ('Alex', "seven")1 C; ~4 v6 H+ N" a+ V3 m7 e
li=list(tu)# ^' f8 Y) H) P9 l( f. d
print(li)
  p4 w& n. s4 F; m: N  x
3 j$ @* R3 r; [- |, |7 \, \3 J$ V" g' J- w
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增7 L, e( q: D. L/ W% P8 z: f

& r  Q5 n9 w; ydic={}4 m4 n( g. A. ^5 t# L7 c: {
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面) t+ e0 F4 e% G* N3 D: E
dic[k]=v1 Y, y+ X' W; k! T. P( ]
print(dic)27、转码n = "老男孩"9 H0 _/ `4 H9 t! v4 s; N+ l5 L+ G
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
1 o9 t% E' B- O8 X3 Ea=n.encode('utf-8') + ]- d  }5 `& ]+ y2 @' S2 ~
print(a)
& n4 \6 c- e) g: H5 ]% Eb=a.decode('utf-8')
6 D6 X3 z  x" W* ]print(b)7 l* i+ F1 ~1 v$ m5 _
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
/ Z& q1 X+ _( ]4 Zprint(a): |1 d# q* `/ Z0 D2 z7 [5 N1 V7 t
b=a.decode('gbk')8 `( s, C: ]5 S# x& `8 I
print(b)28、求 1-100 内的所有数的和
9 _5 O4 L3 h" qcount=1
9 C/ q2 L) j2 _sum=0
0 }0 N  \9 X# y' R# O' ~for i in range(100) :
) L! E) @* I$ R6 i3 O2 R sum=sum+count+ j3 e4 d; ?2 O
count+=1( q1 S) `( i9 r+ X- N: v7 L
print(sum)
% L4 X$ C0 Q- P. X1 l3 H
: q" @7 V0 W" }; L/ ^count=1
9 |: e4 g* y  J' J# K2 b  Ysum=0$ N+ Z# ?/ D, M5 C3 S
while count<=100 :
+ Z) [, n) x. ~( o. ~ sum+=count; f$ b% p: S; r: s7 c: ]
count+=1
1 h$ N; R% T  Z# j" `, [" C/ |print(sum)29、元素分类6 D0 g8 @7 H8 W" C: F" f- m
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，/ e! q  a. Z4 \" |
将小于 66 的值保存至第二个 key 的值中。" s. o! k- G' z5 W' y% T) }
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
# D4 @/ R4 M" t1 V" |4 b# eli=[11,22,33,44,55,66,77,88,99,90]
, O- v7 O# f3 @5 u" Zdic1={
2 \" }# o) g6 K 'max':[],9 C: z6 \8 [6 K- |! C- m
'min':[]
6 H1 r" b& s) S+ i}
- l$ U6 M+ l4 K: gfor i in li :
- y) E4 e: G+ `' F8 u& t3 S if i <66 :2 k% N& G" Z3 j2 p, P
      dic1['min'].append(i), O8 O6 \. D' ^1 n
else:' c0 \( n3 M0 k' i9 N! ?
      dic1['max'].append(i)7 x% c5 {1 J! m4 [. p
print(dic1)
: U  J. G2 x3 c. \8 g4 s" P! y9 O' p9 ^9 N! ?& L, l. o/ a
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
" A" \  w5 l# ~6 }

Python基础知识汇总

主题推荐