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、写代码* j7 F- g9 L) v4 g( N
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) :- }. P* p- D7 ^% G: |) \
name = input('name:').strip()% `- i; X4 A! e
pwd = input('pwd：').strip()
+ l# m' i/ m, E+ X5 R' X1 Q0 N' p) c( C3 X7 K
if name=='seven' and pwd=='123' :+ j3 A/ f3 n' J0 x$ ~2 p
      print('ok')/ Q5 i4 Y  f* K5 T+ R/ ]( Y
else:- C9 J" {" D6 j( k4 B6 E8 Q+ A
      print('error')
' f: o$ O- Y9 L       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)  :! N/ K) C6 j5 _6 V% U
name = input('name: ')
6 ^# @' l; I% P. Y( Z7 T$ D pwd = input('pwd: ')
7 @! J- W% P2 o. n" o( Q8 q if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':# |: M0 P0 d, m$ h( x) g
      print('ok')
0 m4 h+ E8 U( i# V else :+ x9 V5 N4 T( T* c1 [8 R% D
      print('error')! S2 N2 }3 ^* L/ b! J
      count+=111、写代码
! k0 R2 r& F* Q/ G+ U# @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) :$ a5 D- o% r, j8 J) F
if i %2 != 0 :
; A# c- P4 I# i" |* w       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
8 _. b2 U' E8 _4 E if i %2 == 0:
. `& A. }: k  a2 t) N       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"' d; Y4 H. B4 B' F" E3 G
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)3 D2 h/ g5 K) d) P
for i in name:; j! @0 }2 b2 N0 U
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
% S8 f& Z2 |2 U  p+ n22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']* N( M( c2 E  K: H7 M0 H
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
, [2 _! p" f% lprint(li)
* e% @6 I" c) f* K" @( @2 o9 p ['alex', 'eric', 'rain', 'seven']
% d  S( d8 |3 F. X0 w, }c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# _6 l# \+ r( S; bprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')% H/ }& Y8 P* s. H8 \
print(li). h' @/ v4 P: v7 M# F
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']# E5 M( o3 o2 o& [' x5 e1 C8 n
li.pop(1)
; A' Y4 u4 b3 M+ Zprint(li) ['alex', 'rain']) H, I; g2 [' \7 n3 s
指名道姓的删除li = ['alex', 'eric', 'rain']- y5 Q4 a+ L- @: _4 k6 \0 e
li.remove('alex')# x- f, }5 h+ D: j
print(li)* k! p& r, j: D8 c  V. i
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']% d" K% z8 [! N  @% _# r; G" G
print(li.pop(1))0 y0 M) S- f$ h2 E. A
print(li)
: F7 A, r  V& ~2 Y" i
1 s& q, o* B7 f  [- g+ E+ q  B3 reric
0 n  n' h" }) U. c! |['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
" T% ?. M7 |1 {del li[1:]
) `: y8 r, L2 [9 R( vprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
9 t1 R7 n; s' R' gli = ['alex', 'eric', 'rain']
( F8 W9 y6 t! s1 A" Lfor k,v in enumerate(li,1):
3 z) f" t* `( P print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ Y4 V- u% L! Pa. 请输出 “Kelly”* T) p$ O5 Q( e. O
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 ^8 }- ~. K; t; e: _print(li[2][1][1])0 r2 W/ T5 z5 ?, Z
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( r5 C; S8 }5 vli[2][2]='ALL'. w" h% {; M9 H
print(li)
9 ~& g/ s  p- j, C6 C4 G- Q. f24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'): C1 ]& H* D  d9 K
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" _( r; K$ |( p5 p0 ^print(len(tu))
0 Y. S- ^4 H. K* `( f. ~b. 获取元组的第 2 个元素，并输出
( L5 Q1 ^; X1 Q3 F8 Xprint(tu[1])7 u. j! R1 |# ?" L4 b. g4 L% `
e. 请使用 for、len、range 输出元组的索引. p, X: S  Z$ D5 Y
for i in range(len(tu)) :4 s# }; f+ v, |7 R' }. V! X* h
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)+ }  y5 g( r7 j3 C8 ]
for k,v in enumerate(tu,10) :
* j* U7 X$ Q9 r print(k,v)
  |* u# R+ Y' A; S0 i10 alex4 M- Y, J# x1 y4 A
11 eric1 m9 b) F  s2 Y# o$ l0 y
12 rain
/ d, H2 w" V, x5 o& v5 R4 V/ U0 ^
, P; v- Y& r; u( Efor k in enumerate(tu,10) :# N- e4 y. ^  v' J
print(k)
0 S1 Q) P6 {2 }1 D(10, 'alex')- L$ q' i  S% }; T7 i) x7 z' S
(11, 'eric')
" s# Q6 H6 I. d0 Y% m(12, 'rain')
3 ~2 q$ N* O1 H. Q1 ?) `- I( c: P! d5 S' X
: u- ]! n* s6 L- `
25、有如下变量，请实现要求的功能3 n7 r+ w( m# D# @5 S
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

  r% l% r% G+ {, nd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 h- R. L1 ]: Q- ^, p# jtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])* ^6 F! b. O+ H2 d. q1 y: o2 c
res=tu[1][2]['k2'].append('seven')& J, Z% o- j3 q! X3 e3 {

( S1 V" P+ {8 }1 x, z' mprint(tu)1 ?' u  O# `( ^0 _6 ]- ~
26、字典; V0 S' o$ N9 s9 ?( e
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 k, I3 _8 l3 s' j1 V; J& J: T print(i)b. 请循环输出所有的 value2 a. D3 s: m% w% o$ b9 ^
for i in dic:
8 Z9 T' u* a8 X$ \( [ print(dic)7 ]- p6 o4 q  G/ h0 b/ N
c. 请循环输出所有的 key 和 valuefor i in dic:
9 G' J- D. L% l8 Oprint(i,dic)
! a7 v2 [  n. K/ g% a9 u* y& _/ L6 Od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
2 v3 Q) m$ k4 [# ~* Odic['k4']='v4'
7 a6 ?' O7 Q3 ?* Kprint(dic)% V5 I0 l  C" R8 q
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 e$ P. E: ~- S4 N
dic['k1']='alex'/ u# u. F' y! h2 l0 g" G$ `  v0 `! n
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 [$ t' b( N, ^: fdic['k3'].append(44)% M+ w' h# O) O2 l1 x
print(dic)) J  T& x  z3 u1 C- r; c

8 @3 Y1 Z  y  @' f6 Sg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典' t+ Y0 G6 o" X7 o3 U
dic['k3'].insert(0,44)
8 k: J$ [$ `. Eprint(dic)
0 O) b. l9 F8 n9 z5 w27、转换
3 l( Q- b* X' h2 k! b% I! ra. 将字符串 s = "alex" 转换成列表  s = "alex"
9 {. m: p# I: `0 z% U+ b7 o; v7 n8 l' s; Q% T# a
print(list(s))b. 将字符串 s = "alex" 转换成元祖
- G7 c/ c( G! W8 u) ~5 |" xs = "alex": L2 E8 D+ E. B  k
print(tuple(s))5 }% M- K# z1 n: e* |
  R3 c  ^( T1 ]% `" h4 d
b. 将列表 li = ["alex", "seven"] 转换成元组/ g% d) s! p/ `" {2 \1 i0 D6 l7 ]
li = ["alex", "seven"]( G$ F. ~, H4 s( U% I
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
. D( E. z+ Q$ H" e  `tu = ('Alex', "seven")
+ u! T7 s& ]* z- Zli=list(tu)
  g3 V7 t1 w( s4 B( o* C# [3 s8 @: zprint(li)) P& B- t1 [6 W2 U8 @  T$ y' J3 y

  L# e+ \9 J0 Q0 Y; P9 W% N1 F# A! Y+ x* ~8 p2 E
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" ?& ~+ c  y# s8 B, t6 B& ~! n
6 w3 R# S* D7 O; k; b3 O
dic={}$ l& e+ F* @; O: c
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ R, U6 B! f5 \7 \  e8 F) J/ j5 g
dic[k]=v- H- @# p5 f# ~3 l# O
print(dic)27、转码n = "老男孩"% C: R# j" f8 N; w( @) }
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; j2 ~9 p$ x; d- b6 e3 Q( {- V* P
a=n.encode('utf-8')
9 y' f6 u7 A4 m$ eprint(a)
" @% R0 X9 ~& ?2 Vb=a.decode('utf-8')
7 m( N# j- m, lprint(b)
  u  [6 W- V5 b7 k+ Q. {; K' ?b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
) @" c! N: C( ^4 q" p# T* Gb=a.decode('gbk')1 Q! H( I3 F/ u3 S8 Y  G/ Z
print(b)28、求 1-100 内的所有数的和
* r4 ]0 a: C( q: S" K1 s- G& Lcount=19 p' K' {$ Y& `- {( N
sum=0
. q1 `1 |% O0 g) k2 X& I# w7 G( Gfor i in range(100) :( c% x! e( n2 B
sum=sum+count
. j1 [5 _( g" j& s2 X count+=1. _$ ^+ r5 o% |) z
print(sum)
: `$ t$ ]: m( y8 a3 E, p
. S" e/ V: D7 Y; ucount=1
% M1 u* M( w. esum=0/ A0 `, X* Z' {9 ?: w4 ?' F! I5 q
while count<=100 :
% E, Y  N( V/ d) h* }5 U sum+=count& i& [; `9 p# H8 \, }( r
count+=1( ^) _0 Y( y* {/ }: G
print(sum)29、元素分类
/ T4 ^3 U: z3 P- y, p$ }) k6 B9 Y有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
9 h3 {* n. |, e* g" y* G2 H: k将小于 66 的值保存至第二个 key 的值中。
5 }. q- P! l3 I& n0 v即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 c6 H5 `( y/ E' l( _* wli=[11,22,33,44,55,66,77,88,99,90]. _4 Y' E9 j( p5 ]* o
dic1={$ N; B' o& l/ _7 N5 Z
'max':[],; A$ _( [) n' H4 v9 t3 O
'min':[], i9 z0 B7 u/ W: B4 t
}
. R1 R. N6 |4 dfor i in li :
% U, g6 q6 t  [) x9 Z# S if i <66 :
" k* k  b: r. G! H) t0 S$ J       dic1['min'].append(i)
$ v: n. x" J' B& H# I0 x  g else:
& h# t1 I6 c" L       dic1['max'].append(i)
4 m' {  e! ]! G5 b: G) g4 Aprint(dic1)
& x& @* F" N5 g$ w, u! z
9 P( @& j4 G. k$ m. t0 t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}, l$ V# n0 C/ _

Python基础知识汇总

主题推荐