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、写代码2 @6 W6 S3 ^  k9 p
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) :
4 ?) c4 R1 ?' t* I, Q* A! N3 O name = input('name:').strip(): r( T% J4 I: r1 G: @$ U0 R
pwd = input('pwd：').strip()
7 n' A! m1 I6 M3 |/ [* a" B
  l& ~) |% a* E if name=='seven' and pwd=='123' :( y  q) x5 l) h& I: @
      print('ok')
6 K' U) G+ I) ?; i else:
  A1 D, h: N) @( D( b  g" A; Y       print('error')4 U' u* s0 i; s+ Y( y) ], R7 K' U5 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)  :8 s9 e# u8 B4 F8 h& o7 P
name = input('name: ')1 j! P" i8 |5 z8 _- O$ R: w3 \0 c
pwd = input('pwd: ')6 u1 u! ~+ A/ v
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 i+ h" G( z) C' ?       print('ok')
1 p  v0 Z/ H5 [  r' h0 V' L0 F% w else :
8 U0 U" F: r  s1 k6 x       print('error')
" r; ~' y6 c" @3 S       count+=111、写代码1 L+ m+ S3 L& g2 U' X) E
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) :1 y9 ]* @, t: L: ^7 c% e5 O
if i %2 != 0 :: x) j/ B% d7 s% O9 }
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :. ^' y! T$ y# z$ ]
if i %2 == 0:  K7 a8 i+ v7 e# Q: |' 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"2 l, _  N/ Z: Q! g: 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)
- [; E" ]6 T$ H' C) R% Afor i in name:: t" N8 X& T; r/ D, V
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain# f& y6 j. }- ?4 S/ m
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']  u, b7 F3 P3 a  e
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
' X1 @7 `2 L7 Q8 Xprint(li)8 S+ J8 H2 L# r# Q) z' V, t
['alex', 'eric', 'rain', 'seven']( s) x9 \. b6 [# G: h
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( \$ p/ z( F6 [' h3 F9 aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')$ L5 \1 k, d% t7 t% f/ m
print(li)2 }) k; F+ U6 c, r2 k+ h
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: t) X5 L/ z1 B2 L' F. J& i5 h1 d
li.pop(1)+ r3 s& x' `8 m: ^; ^! O$ n* M3 w
print(li) ['alex', 'rain']  [" b1 u# d7 E  G7 D. D7 C0 M! [/ V
指名道姓的删除li = ['alex', 'eric', 'rain']
* h. K3 l- ~- E' g$ i3 Zli.remove('alex')
" B; E1 |5 p+ v' V3 A* _, }% e% `print(li); P$ R, [. X6 u" l2 l2 j
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
% s3 }, j; v/ e+ u# V0 X/ }6 x% Tprint(li.pop(1))1 u' A' T# P# p, ~# @
print(li)
( c3 ?. d  @$ c! Z
) |1 n. @- f# H% L9 T& ]eric- x- {" ]+ U) G, ]9 W+ z
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']* l9 a$ Y/ `4 v
del li[1:]4 X* a: {9 w; C
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
4 S5 d( [. ^# f  u: ~li = ['alex', 'eric', 'rain']' y/ D( `+ y- z7 P! ~2 C
for k,v in enumerate(li,1):1 y! d3 L  s8 p
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  s; B3 r- Y( N3 u# |a. 请输出 “Kelly”! {0 W" Y+ c8 ^5 A1 o
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 o) w8 x" J4 U4 P
print(li[2][1][1])
" R% u' P! Q4 ?, K4 d0 E- Eb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
" Y/ T. @( q. a6 O/ r$ e: ~li[2][2]='ALL'
2 L. v7 n+ F  a+ _' ^) Yprint(li)
9 a9 {% F+ x1 w  S1 d9 r24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')6 X9 `5 Z# N" \
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
0 D- Z5 W- ?7 B) L+ |; g7 E$ Hprint(len(tu))* F  r3 Y) q0 [9 q
b. 获取元组的第 2 个元素，并输出
, r" Y; b1 {+ ?" kprint(tu[1]); w& _4 I% d& G, x, p3 Q1 i
e. 请使用 for、len、range 输出元组的索引" P6 A* U( U! c) ]5 k1 E
for i in range(len(tu)) :* k5 I9 [. S8 B& a& C: g6 o
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
* H& [: C- U) n  d, ]$ m+ ofor k,v in enumerate(tu,10) :2 p) {- A5 \' B4 [+ L4 A3 v
print(k,v)* `$ D" C! U% n4 z  C( ~- l
10 alex  h  I: C1 `9 b$ X
11 eric$ k. Z# _( Y: W2 Y
12 rain7 B. z0 K7 u4 E0 ]( D
3 U  F. i: A' r& u! f) v. m
for k in enumerate(tu,10) :7 C0 ?2 G: O) J
print(k)
+ h; D2 A) ]: y  {0 D1 Q(10, 'alex')
* K0 j7 o6 `& _! U1 }(11, 'eric')
/ m% r/ Y! f5 P(12, 'rain')) ~& I3 ]5 e: L# W: t" n% ~! y

  s  b# h2 X# G7 e6 X* G2 K5 y2 {* d9 |4 l; P* u
25、有如下变量，请实现要求的功能* D# W3 L# w  w$ v; J
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
* D# `. c$ J$ D$ U
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以( J* V0 \. \& h
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 ~& L+ X1 S8 `7 e0 Ires=tu[1][2]['k2'].append('seven')& h  E! [4 O7 q, E

" [% }4 U: |' J0 A+ e2 Y% T$ uprint(tu); X8 h( M7 C! z/ I/ D, B
26、字典  ^1 B2 U  o9 @
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:5 @) m# ~. ^$ @$ C9 z
print(i)b. 请循环输出所有的 value( h- |4 z$ |! C! y6 x5 i
for i in dic:
# ^  V3 P" W; d. Y5 E print(dic)
! a/ K. R$ p3 Q$ |( Tc. 请循环输出所有的 key 和 valuefor i in dic:0 W, b0 C4 i, b: }
print(i,dic)' p6 @- b1 }  @3 Q4 l% j
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典) e4 c/ K# f0 T- C  A
dic['k4']='v4'
/ {; D6 M0 G2 N4 h8 J% a7 Uprint(dic)# {, ]1 v( A# {; L5 b* I
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! W7 M- h9 H4 u0 z8 L3 [
dic['k1']='alex'
! Q; x/ L2 w6 C( y, o+ Tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. z" n" \, p7 f' [* ?dic['k3'].append(44)4 Z" D2 S; N  x
print(dic)
  T' c# z8 c. R4 Y. g2 T
; L% O" `; _  T$ k1 [g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% N. h8 }3 G( `7 s* y  x& adic['k3'].insert(0,44)/ a3 t( l0 w- q4 ?1 |6 H
print(dic)
( J. x3 T1 k8 V& |& k0 Z. }, R27、转换
% w8 m& I" _! J2 J3 N( N$ i' ?+ La. 将字符串 s = "alex" 转换成列表  s = "alex"1 M; I; n1 e3 J) }6 @

6 T0 E# N) p+ o2 n7 A! p# oprint(list(s))b. 将字符串 s = "alex" 转换成元祖
8 ^2 K6 M6 E& ?% `3 q+ g+ X; f: vs = "alex"# Z' f7 {: W' W
print(tuple(s))
) K5 I9 Z$ ]( y; f7 O# z# P& x1 ^. z
b. 将列表 li = ["alex", "seven"] 转换成元组: Q+ C% N, B% x" ]6 d, d' M
li = ["alex", "seven"]" v( W' J& X, h
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表8 W# D7 u0 g  ^/ A% Y, U) B
tu = ('Alex', "seven"), G" F, N& y0 E/ m: {
li=list(tu)' A% ?3 m1 ^( X) p
print(li)
$ b( E# _% X9 ~9 u
9 }, r- T5 Z" n' t! V* Q, y" L1 A1 M) }* G8 X
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增% N5 _7 I  P! o0 L9 q- d

* Y6 x4 L/ e+ t# {dic={}
4 w# K! R% f! h  {, Dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
0 K9 P9 L: E3 N! L( K3 l dic[k]=v
  `0 Z! x* A5 p- J print(dic)27、转码n = "老男孩"* }# L3 N) H# P! A5 P
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: \8 S! \; }; {# Va=n.encode('utf-8')
, I% x, Y) B% [0 s: _$ Kprint(a)
6 N, o5 T/ L, m% J/ `b=a.decode('utf-8')
! i/ v) D9 d  ^) Z' w9 O# Xprint(b)
  O% E+ A" f$ Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! \" o" r& T1 h0 q3 z& yprint(a)
: E8 ^% J+ z7 Y8 _. }$ \b=a.decode('gbk')
" i( K+ L# O, T: o/ ^8 h! oprint(b)28、求 1-100 内的所有数的和. i7 f" T. C, M! l) Y# ~9 G; Z
count=1
2 Y; Q1 B/ E" q* D; n3 A$ ?sum=0/ q" l! K* N* I
for i in range(100) :/ G3 x  ]% P2 \4 q+ [
sum=sum+count7 A  \% p. ~3 B* l' A+ x! A8 Z
count+=1
- \2 m4 f- i3 _% B; nprint(sum)! V8 N# t$ @$ k  `

! X3 ~) T* n$ zcount=1
& {! K, B) V# b! z$ ^: T$ i2 Esum=0- ?: l/ l& t: g4 i, R
while count<=100 :
; f; D  q# Q7 s$ n3 Y* v# s sum+=count
& S! v" D: @- m! r+ F, K1 Q9 b count+=17 @' T" f2 \' M! s2 g
print(sum)29、元素分类) N: k# a3 _( I1 F( w
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& s: D* Y- j2 ~5 F8 a" ~将小于 66 的值保存至第二个 key 的值中。! ~" ^2 c, ]  }0 I
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}# \6 u: g* P9 |, p, M) [
li=[11,22,33,44,55,66,77,88,99,90]
# H+ a% X5 X& B1 F2 Q8 ?" pdic1={9 s. v) P3 X* w( @
'max':[],
- e/ }# y2 W8 |! f3 p- O: M3 k; ] 'min':[]
) H5 }  Y3 i0 a, U}( C0 l# B! ~. [! ^8 ]2 [. N
for i in li :% Q  A; p3 o2 h, a. W
if i <66 :: N6 ^! z( S; {6 e  l
      dic1['min'].append(i)- M6 \  W9 C- X, _* o1 p
else:: y5 G- ^! m1 M: e( N
      dic1['max'].append(i)
8 t! X1 c) }: \3 h4 k6 k+ Sprint(dic1)5 C: H( O2 J& a( k6 ~

: ^2 v) ^! M1 O% @---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
, a+ F/ m4 X8 Q* K# O) o: K7 H

Python基础知识汇总

主题推荐