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、写代码: B$ c. `& N( Z! U
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) :" ~# ^) \! J# s5 ?! X5 y& t
name = input('name:').strip()
! G/ I, e9 w5 k" l4 q pwd = input('pwd：').strip()1 E1 m0 F' }  v- o' V, d: _1 u5 J
0 r; l7 K% P! Z7 ~
if name=='seven' and pwd=='123' :
# Y4 I1 _8 F( @4 N. K       print('ok')1 M/ u9 t$ z0 O0 |) G) N
else:
5 Y9 T3 q9 K( |' o! b       print('error')
/ _# t! z0 s; Q! |$ L! l* _$ B       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)  :
$ x8 C) P" H( v+ g+ k name = input('name: ')
: m6 U; c$ s' |1 p7 m% w6 \ pwd = input('pwd: ')1 K( a' m8 i4 e  ^7 c2 R2 s' {
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
! O- {9 n: _2 h' n5 R       print('ok'), S8 h/ _, s" X* o  t$ h
else :
2 I/ h! B0 M7 O& b+ z, b       print('error')% ]0 @5 O: X# M+ w5 ~7 i8 e/ ~
      count+=111、写代码
) F! h. U; C* _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) :
$ _; s  |( l0 d, U- l8 s0 h7 k0 }& U if i %2 != 0 :  j) n) H: a. _. ^& 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) :
6 k2 S  E! G- t1 G% P8 e if i %2 == 0:
4 I/ T+ _' L3 k' {0 H       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"
7 i( c5 ^' a+ q: |1 M$ K9 ba. 移除 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 t( Y' I* m. F
for i in name:
. e3 P6 z* B- A5 O8 [/ Y% U2 ^1 j print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! u% r" o8 A# u9 D1 M22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']1 c( h/ K- }- \9 o0 N
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ( f' ]' }8 \( g' ?6 N$ n4 }, P
print(li)0 q" O) I* b" N" u& [
['alex', 'eric', 'rain', 'seven']; @4 m8 A8 x9 Z! P: C& |( @! i
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
' k) k9 C! i) Dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
  M* j$ l! L4 U; zprint(li)
1 V3 F+ _+ z4 m) R0 Pe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']2 }$ b; P  K5 \& {& _* A
li.pop(1)
  X0 q* i" G# y( @print(li) ['alex', 'rain']
4 ]+ R; ?$ A* r% r( N指名道姓的删除li = ['alex', 'eric', 'rain']& b! L0 }( w) U2 Y- A/ d
li.remove('alex')
( _! Y& e/ b9 q. W+ v) H& Fprint(li)
9 p+ s# Z+ Z  ]# u2 X3 Tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']9 D- p1 K3 r/ c, E" d3 @5 z3 {
print(li.pop(1))
" R- v$ W1 n  O# M3 Sprint(li)
' d$ D* ?( t0 [2 U% s/ v! `; u* v8 a3 j1 K' g+ ?
eric; H6 s2 H: r8 d; P* `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 @* [3 D! g$ x# j* Mdel li[1:]
5 u* o  I# Q; p4 xprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)& Z; G  h- Z2 T# u% `
li = ['alex', 'eric', 'rain']" u" ?7 i! N) a1 I- L8 h
for k,v in enumerate(li,1):
: K7 O, E7 x8 K5 s print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ X; }! K6 u) s6 r
a. 请输出 “Kelly”% T* _# \# z& y& ^; t( Q
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* }6 x( F) b3 O2 n, Kprint(li[2][1][1])
8 a# Y& J1 ^) |3 o, l  rb. 请使用索引找到 'all' 元素并将其修改为 “ALL”$ [" g8 `' i; `; D3 Y
li[2][2]='ALL'2 w7 j2 s% h$ _, g
print(li)& H, E7 L: N7 f9 a; {; o* a! c3 @
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; ^% x$ l' T* E$ \. ]# Ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')) j' v$ L  C3 W, k' T% @
print(len(tu))7 }  W6 v1 ?4 Y. J& j
b. 获取元组的第 2 个元素，并输出
3 d% i1 N" H, R7 M0 [& a0 ^print(tu[1])
7 k% |1 S8 k3 m0 E9 De. 请使用 for、len、range 输出元组的索引
9 j; \) j" I# p2 p  X# [3 S+ Afor i in range(len(tu)) :$ u. E6 \% ?1 O$ a/ ?
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
! h: E1 w1 V+ b: ufor k,v in enumerate(tu,10) :
! q3 Q0 \# m! K; k  d print(k,v)
6 z0 P$ k& S8 y0 z9 k; e10 alex
8 u7 h2 Z; s$ ?2 r+ F11 eric* c& r! {5 B/ u
12 rain
2 i" V  p: p6 Y. @2 k
1 R# c& S& {3 x) N4 y! U1 m. {for k in enumerate(tu,10) :$ w$ ]9 o& M( T
print(k)4 z/ f  @) ]* w! {4 j" l$ h$ w
(10, 'alex')
$ k9 {- B5 X% |(11, 'eric')* w2 ^" \" |8 C" D
(12, 'rain'): {' [: Z( ?' U: _
8 z) \9 s3 ~# @6 o. E1 [

$ P& p( i( d" Z% h: ]25、有如下变量，请实现要求的功能, g- c7 V$ D7 G' F! T9 |( h# N7 K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
& P1 Y+ Z; W- H6 w! |& }
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以4 ?8 D  r; A1 e( Z4 X$ K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])4 E& x& M. I) F/ \
res=tu[1][2]['k2'].append('seven')
- ~" x6 a) o) j  K& W0 p4 ]9 U
9 U7 Y: \! R5 f/ w* v( `9 mprint(tu)
& [5 H$ E3 D+ r: c' ^26、字典1 W' `: t3 L2 \! X! \
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:# [4 D: N7 D; m: E# v, s
print(i)b. 请循环输出所有的 value
/ }1 ~" A2 G8 e; o, Vfor i in dic:/ W& C# C/ ?, R( i0 c' ?6 ^
print(dic)2 x( [  g/ }3 D. ]* }
c. 请循环输出所有的 key 和 valuefor i in dic:" E8 P: c4 M- D1 X" x- U* P9 x; O
print(i,dic)3 C2 P3 \) u2 W8 I: G3 ^6 P6 ^% O
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典8 `$ V. V' e1 x% p
dic['k4']='v4'
( R- Q3 d6 P' G3 s0 C3 u# gprint(dic)
6 j' d  v2 i, i% n2 u( {' Y2 y8 We. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 {: P9 j3 A1 @& s8 @$ Sdic['k1']='alex'
1 P8 D3 [4 ^5 D; ]: Vprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典0 g* |: |2 S3 k1 X
dic['k3'].append(44)& J# H$ t* u5 \! |
print(dic)
: k2 {- T2 \5 Y' D) B
% P  a' A' c2 G; `g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ H( L6 C2 R9 e) G" M" G# Idic['k3'].insert(0,44)
+ f6 h/ o  V! @" q2 U  Iprint(dic), _% }- z& x8 g
27、转换1 d3 t2 C' z) K( Q, c7 ^- O
a. 将字符串 s = "alex" 转换成列表  s = "alex"5 `* W( k: O; H. Z% j8 x
4 G8 c* @1 m8 @0 b4 T
print(list(s))b. 将字符串 s = "alex" 转换成元祖7 \3 y6 A6 ~) }7 U+ Z7 N( q1 [
s = "alex"
4 B, c7 c5 @" k' p9 L+ R) s; o6 kprint(tuple(s))
7 d% {; w* I/ }+ V' I5 U* A2 c; M7 K: t5 ?8 v8 B
b. 将列表 li = ["alex", "seven"] 转换成元组
$ n$ `! @; f  K: o7 i$ xli = ["alex", "seven"]
- J! Z. g( o& Z+ Bprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表3 ?' T7 A1 A/ Z/ x. S3 y$ @; \
tu = ('Alex', "seven")9 l4 H. Y: D# V& q
li=list(tu)
; f) ~( Z& ?  Pprint(li)& s- c" N1 R' J$ m
4 t1 I) V: ?9 M" M

* H3 |* j8 g5 j" f4 V* Gd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
+ e& O% r, t* {
/ d/ {; ^1 m8 N* n! h! v1 Ydic={}
6 c' L- `  o: Hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面' r8 g! i, _/ a* [: s1 t5 c
dic[k]=v6 i% J* Y6 ~/ e4 p- m( V
print(dic)27、转码n = "老男孩") [" d$ r: a7 o2 W" `
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
' }5 p) J% M/ f1 |' Ka=n.encode('utf-8')
- d( I4 j- y7 `* U& s9 u/ Yprint(a)3 J+ y9 w: v# w" o' y# C
b=a.decode('utf-8')$ M" X0 h1 R6 g+ L
print(b)$ H: i9 ^8 F- u
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 s: a  a: c* @4 Y( i0 r! E; ]
print(a)
6 s9 {% t0 P/ }; `- {/ yb=a.decode('gbk')  Z9 K1 |; g3 D; o9 g6 K) o
print(b)28、求 1-100 内的所有数的和3 j2 Y) S/ E' ~9 \: [  I* i
count=1* z9 K. q% D, F  Y$ w: l
sum=06 p( L; O$ y2 Z5 ?7 x* H. J
for i in range(100) :
3 j" q# y1 y, Q5 `; R1 e4 t7 R sum=sum+count
1 U6 }' B# _# N! j" O( j; k count+=1
6 s9 W4 w# H( Fprint(sum)6 Y7 ]5 G2 g2 I- U& n

, N+ @1 ~+ v7 [8 j8 ]& p$ F+ M0 B1 Xcount=1
9 p, T6 u: z+ }sum=0
3 q. x2 ]8 P. v, ~while count<=100 :
$ o: ?( y2 _9 `+ o/ x; O4 ]! p0 d sum+=count
, E/ q' }( C5 [ count+=1
* y- m3 X$ e3 }/ dprint(sum)29、元素分类! J2 R  v. s5 {, w* m/ @
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，/ o, g) `  a% _9 n# E
将小于 66 的值保存至第二个 key 的值中。# F+ A# A- \! u4 Q! s
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}5 c5 `' n  w0 B) E3 {! _
li=[11,22,33,44,55,66,77,88,99,90], X6 Y6 }6 z/ d- E. Y
dic1={
5 j- q# ^3 ?. y  |3 V 'max':[],
$ z3 X7 |* T0 p2 o% r& e 'min':[]
( z$ x0 A- I% V}
2 h, I9 P( u9 ]* X* [! [# Kfor i in li :$ g: r: L0 j6 k/ V$ e1 r& r
if i <66 :8 P% S2 |8 G/ i! N/ K' _  S
      dic1['min'].append(i)
# @# E5 a7 ^  h! A8 D- a7 _- V else:" G* P8 K8 X2 R! I
      dic1['max'].append(i)
8 l# K6 ~% [' H% D: j- c% yprint(dic1)6 n4 n: s& U: G$ w

) @- p! w1 r( C---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 Z" z4 N* p* I. \4 Q# d' @( a

Python基础知识汇总

主题推荐