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、写代码3 C* e* X% R" P. L
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) :
$ [: t" Y" j" R! O6 C* j- x name = input('name:').strip()
: x0 N" J5 [# E1 o8 e" d0 f pwd = input('pwd：').strip()6 b0 Y- I. M( E+ l
+ v$ v4 B8 I+ l: L6 {6 M
if name=='seven' and pwd=='123' :
& f1 b' w9 E: n7 t5 K  Y) v       print('ok')! Q  r" s; Z) c( z: u
else:4 l# `% t- D  f  H6 T" i4 T
      print('error')- C: S& K, J" D' e! q) }
      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)  :
$ L5 e+ g# x) m6 a% O0 a! F8 M name = input('name: ')) I2 ^. H  H2 z" [8 m: f
pwd = input('pwd: ')& L' r) `& i6 I/ \, b+ Y- x
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':/ i5 }- ^1 Q; t1 X! h) ?
      print('ok')
' R; U2 d7 y9 | else :
) b! w8 ~9 w0 s- Z7 k       print('error')
+ w! ^) w9 h5 z( j  Q) v" f2 V       count+=111、写代码
1 |( D# X+ n1 u% Z- v5 [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) :7 N1 o- T1 {# A4 ~% K' B1 n
if i %2 != 0 :* j9 w4 R( }# z2 ^% M
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
# R8 z# p" }# v" }2 H% H if i %2 == 0:
. s3 E6 ]' y" z+ _. D  @       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"; D8 y- E2 o0 M# {
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)
/ ?! y# s. ]9 E; j4 a$ N' p' Yfor i in name:, Y, O) E( \$ I2 a, c1 [
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain' ?$ c! e7 x* W  R" \8 |3 i) v
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']) V9 F% z6 _6 y' k0 ^
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
# b; D) j% H! a# P0 \# S$ n/ Yprint(li)6 ^  l6 ^6 m6 r% m) J
['alex', 'eric', 'rain', 'seven']
, N2 h; C# {; b5 Tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- g0 ~  q0 b2 F$ k2 k5 S: Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, n' ~3 V7 h5 C( s' R! l% Vprint(li)
# {$ Q1 o# B# n% f% n% Ce. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']% v6 T7 V# ?: \: J
li.pop(1)& o  D' L# n& Z6 I; C; g' W* _) S
print(li) ['alex', 'rain']# d: I9 j4 ~; U7 K% X# R
指名道姓的删除li = ['alex', 'eric', 'rain']$ }/ R7 V. B2 {, ^+ E% `! b
li.remove('alex')
( |. V5 H" c3 }4 O# Uprint(li); G5 E1 {( a& M, [
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ @' h* i5 V: a1 m; Gprint(li.pop(1))
7 {. a9 `. E* Jprint(li)
% b$ |" H& `$ {% o
2 S" L" L  X  G" c8 Q, {eric2 E7 `$ f+ m5 C) A' O$ h
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
% P# ^0 Z+ d* G, M6 }2 xdel li[1:]
2 H7 p, }9 {& n: Mprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
2 G" Y6 H2 d! m% |: H* ]li = ['alex', 'eric', 'rain']
# ^5 I3 |( y, ~- Dfor k,v in enumerate(li,1):
# W4 q/ k' j3 t3 @ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. k" B1 z" r4 h/ i/ ya. 请输出 “Kelly”' M; U- I2 m0 z; U( m
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]. W4 H2 [) b' h" |+ [: Q
print(li[2][1][1])0 W" U! a9 J$ B) }- r2 r
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ e1 C6 F1 Z) S* j  S% ?4 ali[2][2]='ALL'7 B  T# X$ F# }* B" z# K  S
print(li)
: Z$ a$ `+ G$ Q24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')3 b0 ^" s& w# c% |0 C
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')+ Z0 }3 E( S! q9 @" b
print(len(tu)); Y, Y2 n7 |: l$ Y% g
b. 获取元组的第 2 个元素，并输出
/ k( U5 L+ k! D7 {$ B+ R6 i8 v1 Fprint(tu[1])  a/ Y5 v) m5 e  m* X& m
e. 请使用 for、len、range 输出元组的索引
3 Q; E0 a! L& }" b, h7 X2 Ffor i in range(len(tu)) :
1 G/ S  m/ \8 E/ n print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)2 o7 c/ I6 Q2 \4 T% N9 m* Y
for k,v in enumerate(tu,10) :
: R7 E/ i0 O2 e0 ~: s print(k,v)
" e" O; n" S% n7 Q* S7 k: E1 O10 alex
: n5 Z! d! ?7 m. \6 M/ Y11 eric  Q7 p% S, v, _
12 rain

, y. o: c$ ^& }" x; w8 `for k in enumerate(tu,10) :/ J5 L# p: L6 s, Z
print(k)" |: W0 U( F: u! b
(10, 'alex')
  P6 c: [# w4 Z5 L(11, 'eric')4 O9 N) R$ b+ K! @; V; l; I  u1 Y4 l% T
(12, 'rain')  x: w: \% x! z9 Y5 H# L9 {
' w5 B% B+ m+ I5 `2 b; s% O
* m! a3 `* ]+ ^; R
25、有如下变量，请实现要求的功能
0 m! Y4 Z8 A9 k9 r# ]% Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
  M: t* }% P' w! M* `8 q; W
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 w: u' S* R# B* K% g- h0 o+ F( xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
4 V' b+ `; v% Pres=tu[1][2]['k2'].append('seven')1 p8 ]- b( W; V' d: i

) V: I! V0 n# }% ]* P" Oprint(tu)7 |, p+ N7 D% C% B; [) k$ n3 r
26、字典) k3 Y5 i. ?6 F8 k
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( b# V9 b* E  v" i, f print(i)b. 请循环输出所有的 value$ T6 J' R  G+ F/ L8 z4 r2 E1 H
for i in dic:
8 x! X+ Y' ~' l5 q5 j0 q print(dic)- S; z  |+ w3 m7 e
c. 请循环输出所有的 key 和 valuefor i in dic:* f! t& O2 C# Q" E' d9 U# P$ }
print(i,dic)+ a  y; g/ L3 y1 s; J. A
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典. ^0 i: p+ U- {! `
dic['k4']='v4'
. w( F) U1 c6 d% J0 }print(dic)
: r- F. t: B/ }) H3 v. c9 T: p% Te. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( P3 \& m! ~3 Y6 jdic['k1']='alex'6 \9 |) `, c2 S' u5 N) t
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* N) U( z5 m* S5 q+ l" v. \dic['k3'].append(44)
  Z. B7 O5 P/ [2 S/ q' Wprint(dic)
3 v  N2 _" a- g5 K
7 d4 _. x1 i& B7 r3 n8 }( w2 _# cg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, D& F0 _; N3 ^2 i
dic['k3'].insert(0,44)8 p0 }/ g& E% }* p% l- \
print(dic)  v9 P% i+ R- Y$ J: s0 g
27、转换) d( H, q" ~) D3 v
a. 将字符串 s = "alex" 转换成列表  s = "alex"
4 p% q' H1 I+ W2 i. r& L9 p7 c, x& o, ^
print(list(s))b. 将字符串 s = "alex" 转换成元祖
- F7 C- T. v$ g) c& `$ x6 |( _/ B! Gs = "alex"  ~+ v1 b5 p4 a, |
print(tuple(s))0 [+ b9 b5 N# p# [# H+ @6 x2 r/ G
, @6 J1 {4 d# r' \( F, s$ e
b. 将列表 li = ["alex", "seven"] 转换成元组7 F& J0 e/ p/ ^; f2 U
li = ["alex", "seven"]9 F( v8 E: J2 D, s) Z
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表8 S; g& Z) z  t
tu = ('Alex', "seven")
/ L; T8 [  Y  V  D* N( S7 Ili=list(tu)5 v! C1 l9 Q! y
print(li)% p3 L/ [1 y2 l2 X
! r9 b* q1 J4 z

/ t" M( B# m# i; ~' Fd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
1 m; J, C6 J, w7 U9 b  }2 G6 Y) R
+ G0 Q: Q3 Z# \, A6 A& hdic={}
5 y" v$ x+ Q0 O' j: zfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
, p0 |( I+ C8 n% s" B9 U dic[k]=v
  z6 U% d+ [& W/ a print(dic)27、转码n = "老男孩"
+ B. e/ _# E/ c& xa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; }4 h- C4 j1 ~
a=n.encode('utf-8') % T* X8 g) R7 x7 e" }  G: N$ k
print(a)
8 Y4 `$ `/ l$ ob=a.decode('utf-8')7 D" R5 N& Z, |
print(b)
* N- D3 z  u6 Sb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- H7 a; l& e$ O6 lprint(a)6 @6 f7 l# @# d
b=a.decode('gbk')* T5 m8 V, n+ S. Q0 r; ?% J
print(b)28、求 1-100 内的所有数的和0 c" V6 |- a. u( P' _: x
count=1
' r. ?$ I; j$ I$ O5 i9 p9 msum=0
" H* [! {' s  |* M# efor i in range(100) :
. t# P+ h" ]) P: C sum=sum+count
0 i5 P7 N. I- ~% F. l3 j count+=1
9 ?7 B/ L" u# k9 Uprint(sum), r8 ~9 c' B1 L2 z& @& g

2 S( V. g. C+ P/ \8 h6 V9 Fcount=1
) I4 e5 S2 @6 J; ]sum=04 G6 U: L: b( x# P1 g
while count<=100 :2 I5 G8 F0 C8 N6 z1 w& [
sum+=count/ `. {# G$ V6 x0 e4 `2 _! z
count+=1$ k0 Y) {  A1 e4 E/ e* o( ]
print(sum)29、元素分类
" u5 _) s0 Z) s5 K5 ?" _0 I8 q有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
" D- T* K5 V2 H- J1 j将小于 66 的值保存至第二个 key 的值中。5 V7 n$ H' y+ U) i) p
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}0 F# k% w: H) P0 P* l' S4 d7 q) w: H
li=[11,22,33,44,55,66,77,88,99,90]
7 F5 \4 y- r  O5 H( vdic1={7 Q7 r$ K& I) r! s
'max':[],; C& j  v/ }! E, b- y
'min':[]' Z& X, r( y5 o* {# m
}& B/ ?: C' q% k+ k* V7 T/ b
for i in li :
; R3 u# H' G2 p if i <66 :4 ]1 u7 t" V  f% e
      dic1['min'].append(i)
' Z2 q# Q8 ]! s else:6 S  b6 ^$ Q# n- G
      dic1['max'].append(i)1 z* N3 O, T, E2 ]" \8 F
print(dic1)
, F8 S% C$ N5 J8 n% M
  ?8 o/ }6 K4 @6 `& S---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
+ a0 R+ o% D5 O) R" l) o* v

Python基础知识汇总

主题推荐