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、写代码6 L% C0 D3 v. b' E& t! 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) :
; S( L5 S% k$ R: k2 O name = input('name:').strip()1 p  Q0 W% T' S. w
pwd = input('pwd：').strip(), ^, e( Q7 H0 Z% f$ X6 V& A

; B0 |3 `: H+ }" r7 |0 p if name=='seven' and pwd=='123' :. W; x0 m+ y/ S; L- O9 l
      print('ok')6 D! o( e& x6 V* Y& D
else:1 W) R! q8 Z5 ?$ p
      print('error')
; K. O+ a$ v- Z+ r- C6 e# R       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)  :! e- {  h% [( Q/ X; i: V( |9 W# Z
name = input('name: ')
0 S* X$ ]9 t- T0 i5 y$ L pwd = input('pwd: ')! h4 Y  m: z- ^/ p3 m5 w
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 n( K* d0 V0 k6 L1 a. Q; |+ Q       print('ok')% H# p7 d; F% i& [
else :8 P+ Z" }- d0 g4 I. z
      print('error')
# \0 y  J/ P4 [* H       count+=111、写代码: N: [0 t; v' B7 e" v# d2 |
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) :4 M0 s9 _" R5 H! c" \2 a! T
if i %2 != 0 :' G- Q- |/ z- l$ v2 p" J/ A' L  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) :- b- G) m% ^) ]& Q( g0 k
if i %2 == 0:
$ Q/ V+ n. t7 y5 c3 }5 X' d! C       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 `" J/ _' l, w
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)% p5 o3 c/ V3 |
for i in name:
! C" y# y" J1 P print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
4 l) _8 K" o9 P$ v: f% r" g$ w22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
: @2 T5 [. B# w/ r1 pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 j" u! d' i+ X9 k3 U2 N! z# [0 Jprint(li)& \6 G  K9 q! y+ w. f2 E( J
['alex', 'eric', 'rain', 'seven']
5 ?$ v0 ^# {( [$ ~, k/ P5 u7 w1 Bc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* B: ^7 g; U+ p# Z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')1 W* D% f7 N% l( V  \# h! i
print(li)4 X( n/ f$ J% ~/ ?4 C& S( ^' B
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']9 M: |. e3 o& S  i. \# P
li.pop(1)
7 a3 F2 M, M% o  E1 m3 R5 hprint(li) ['alex', 'rain']
6 T# }$ f2 C$ f, P6 g5 ?7 z6 C* _指名道姓的删除li = ['alex', 'eric', 'rain']3 ~& p7 R+ }/ S, L& F
li.remove('alex')
) @; d- B( s* X' x" W3 c, eprint(li)9 m  e% ~! j5 ]+ |# _0 S
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']" V- T, s$ t& q8 M( L
print(li.pop(1))
. i5 w3 r+ j1 I: g) Yprint(li)
# a0 Q! X& P/ u+ f4 @
$ k( \( f9 I  _eric
* z$ y  a: H$ z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']# v- C0 B5 x9 D2 T
del li[1:]7 M3 l# @8 z( L- n
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& i$ E" E8 }$ X9 j# d6 Y) [li = ['alex', 'eric', 'rain']  d* m8 |. [$ E  u& d+ Z
for k,v in enumerate(li,1):' R* E0 ~1 y5 a- V* ~
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 L8 V& W1 F0 J, L" v1 oa. 请输出 “Kelly”$ n7 h" g, ^* K+ F' D
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" U! _! J. u0 j$ y+ ~. O  Rprint(li[2][1][1])( h  e3 J4 k3 m3 H, m$ b9 ~8 H) k/ a
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”2 r- A1 p0 g# J+ X. T0 v
li[2][2]='ALL'
2 d) }8 Q) O+ d' g! G& Sprint(li)4 w  z' k6 a* _% t" a
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 y$ K8 m! x$ B8 I0 X$ }a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'), A8 Q$ j" n0 ?& W
print(len(tu))9 j0 Y9 S4 b  l
b. 获取元组的第 2 个元素，并输出. x- `1 L" A0 ^8 p' w4 a
print(tu[1])* R* O! i3 o  k
e. 请使用 for、len、range 输出元组的索引
5 n) h1 }4 Y5 Q2 {. S3 R2 afor i in range(len(tu)) :
( S9 i" o) _3 Z) `( c( C% V& t) O print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)* _2 i2 \3 F; q! g
for k,v in enumerate(tu,10) :. q3 U; O6 o9 {& I+ M4 z  D. D
print(k,v)3 Y0 c  K$ B- \# B& X
10 alex
$ V2 P7 N& _9 k3 w11 eric7 H& o9 f. M# _7 H% ~
12 rain

. S1 [; h7 x) |$ H. Cfor k in enumerate(tu,10) :6 F3 {1 H9 P9 t) V
print(k). B2 p1 m9 U2 T+ F
(10, 'alex')$ R( x  D. O& w- o) {+ u* q! Y* H
(11, 'eric')# M; v4 P, q4 [$ s
(12, 'rain')# K" _9 O9 L& c* L$ I; |& a5 o) T

( z! |" v: k/ {* N! |
3 A' U. {9 ?# E. Y" E/ w25、有如下变量，请实现要求的功能
* l8 [9 ]* k: D7 m- e" _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

. @" C% i* r- N, c7 r8 D8 j0 p0 Ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 r4 D. E( t0 m# b! I, {tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])3 T0 K1 [" I2 s, W
res=tu[1][2]['k2'].append('seven')
* l' K* Y: B3 k( J2 D& m3 @7 t# j- z, }& D2 H7 W/ C
print(tu)
* b* a. I- K, L) K26、字典4 n. z, }) [9 p# A3 u* ]0 z. I# ^8 F
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:8 g! x5 o) t8 }: M# y6 P: k0 {
print(i)b. 请循环输出所有的 value
+ K* j, m$ X* G- w2 |for i in dic:
8 Z" ?9 l  J' Q5 k# B9 A! n% L+ v print(dic)1 W/ w* I; V/ g  U7 a! o
c. 请循环输出所有的 key 和 valuefor i in dic:/ @. }. z, k& L' X8 _
print(i,dic)
  k6 c" H0 v& ^d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
, l' a+ O1 i9 w9 Q& u! Tdic['k4']='v4'. r4 l9 h2 l3 ~+ N1 p% h& k: Y" {
print(dic)
6 d2 ~; e  X( r' V7 ]/ X# ?e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典( ^6 @* ^0 D$ p- I3 h5 M  r: n, ]
dic['k1']='alex'
9 ?# D) p% K/ e" `; c* H+ tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. ~: p" M; a! |4 E2 S1 m4 [7 d
dic['k3'].append(44)
+ S* j7 J  t* L( J! Aprint(dic)
9 G1 q1 z7 R- A) S: q* {8 `# a) x1 ~5 l
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典. g) a# v) r1 y6 ]
dic['k3'].insert(0,44)3 n8 `2 i& M5 F, M
print(dic)1 I4 H* k/ x8 I5 A0 R( T* W
27、转换" ]  L' O" _; x2 U. C0 [
a. 将字符串 s = "alex" 转换成列表  s = "alex"' r6 {" r$ \+ y* H# Y+ h; h
5 o# |) y7 j2 N7 W
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  ~& N& U8 t7 Z% d& \, M9 ys = "alex"
* a, W* K3 x' y# ]% Uprint(tuple(s))
7 e5 S, h' W$ B! u/ r2 K2 O1 b5 a- m- W* E8 w' s9 Y: U6 p+ A
b. 将列表 li = ["alex", "seven"] 转换成元组
7 T: a+ A6 t4 T; g/ h1 i0 D' Mli = ["alex", "seven"]; g4 @5 a9 D* u7 u6 ~
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) n" ~9 _5 y* o" R8 Q( `" x& btu = ('Alex', "seven")
3 N& b5 f, V+ R8 W) ^1 T# B6 R: kli=list(tu)
5 A3 J2 y7 }& G  b1 `print(li)
: H( [3 [0 {; M  a  B$ ]
5 A5 ?7 z  j. b8 V$ }1 O1 Y6 O
8 n: ?! f+ u7 zd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增% ~3 v* n9 O: o4 f; M- L; r

( ~* |7 l) l! d- {( _dic={}9 e0 V8 \+ z( M: x& c
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面9 b( Y& g7 c6 k
dic[k]=v
  G  ^. h9 b2 a! W3 H print(dic)27、转码n = "老男孩", F1 Y- p+ |" H: Y' }
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩") ^6 x# ^4 x9 X6 m
a=n.encode('utf-8')
9 Q! b5 }2 E& ?% k* i. H& Yprint(a)
* H% }. S* D0 x  \+ B( Ab=a.decode('utf-8')
. u) F; M0 N' z8 _: u$ y1 Tprint(b)
. ^+ P8 ?* Z5 U- u& H6 e/ j5 ?b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
* N0 ^+ y& _6 w) C  n9 Iprint(a)
2 [8 m+ w1 Z7 z; \b=a.decode('gbk')7 g1 [. z  p6 q0 T
print(b)28、求 1-100 内的所有数的和
% l- Q) q; V9 Z% R1 q% d% dcount=1
. _: T, g% r0 r  ~. `8 zsum=0
. }! x( \* W# X8 Zfor i in range(100) :% M: P+ @$ a6 I" Q; ?: e0 U% Y8 L
sum=sum+count
3 P7 v% Q! r- t count+=1
' j8 u2 g, M4 E+ Z+ S) Zprint(sum)
8 U8 Z! G# V7 h' I& |' o$ O5 l: {/ d% D; \
count=1# w  D! s2 ^  f1 I
sum=0
: @2 ?/ M& B4 Q& ]* B7 F( Qwhile count<=100 :
: D( g4 O: H3 e2 `5 ? sum+=count! G: z& z% v0 {: p1 f7 y
count+=10 a4 K7 B# f/ S6 t
print(sum)29、元素分类
7 \! p) g$ T& Z2 `4 n, x有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。9 G# D( d# R6 i
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) `5 X  B( [' q6 L! s* o9 g
li=[11,22,33,44,55,66,77,88,99,90]! [" L' o4 p* T
dic1={, w, E, Z8 o( q: G  L
'max':[],. S6 n; n! A4 c# G( o
'min':[]8 i& c- p1 P# g9 I, W8 H9 ?3 B9 u3 Y
}( d( j, I4 n. @5 g
for i in li :6 A5 g: e: s( m, j  Q
if i <66 :/ t" l( [+ c' ~+ ^& S/ w
      dic1['min'].append(i)4 q+ A3 A& P" a7 R6 i
else:
+ C# Y0 v6 L! G       dic1['max'].append(i)( l: Q1 `* Q7 e# I! Q- V; B
print(dic1)
  B* d4 w, u, B
0 r0 S5 z+ T/ @---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 i- C" x8 ^+ @

Python基础知识汇总

主题推荐