Python基础知识汇总

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

6 e+ l% {/ t% d$ a0 V3 x) K* U5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

多行注释  """  """三个双引号或是三个单 引号把要解释的内容放中间， ‘’‘  ’’’

6、声明变量注意事项有那些?

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

% v! u/ ]  Q3 N0 ?6 ], R8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码
+ P: P# w4 n! j2 f. ]3 ua.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
/ ?' B0 x+ |$ s/ X8 |) kpwd=input('pwd：').strip()
8 I6 d( S# a: s' |if name=='seven' and pwd=='123' :
2 w; ?. o& f- [# ^( a9 K( t5 u    print('ok')
. @" g! C; r. O1 K; B, eelse:
    print('error')

% {- J$ F. S1 ub.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
' q' q$ N4 r2 f: I& hwhile count<=3 :
    name = input('name:').strip()
& A  S# q7 j  k# V5 w) A    pwd = input('pwd：').strip()

6 \+ y+ a0 o4 `  P    if name=='seven' and pwd=='123' :
1 P9 {  ]. k7 |$ N" M        print('ok')
    else:
        print('error')
        count += 1
for循环：
3 x' K# o4 [% rfor count in range(3) :
    name = input('name:').strip()
5 `+ j& ]1 T' ?# R% }2 L    pwd = input('pwd：').strip()
! M' |- {3 m4 s  u/ d8 y- \7 E) I2 M* E
    if name=='seven' and pwd=='123' :
1 E/ n  b" t4 ^6 E        print('ok')
7 q; p! R: G  S5 O; L  ?    else:
9 b9 G' E5 L7 w) x( I* ?  Q8 A        print('error')
! f* _5 X: C$ N$ Y; n# r3 [        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
: Y' `7 y$ ^' V4 [0 `count =1
while count<=3 :
3 J' G; S# X4 m8 `    name = input('name: ')
  a1 D( y6 X, K0 _7 }, \4 T    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
, V5 h, y, L- b( q1 c! d        print('ok')
    else :
        print('error')
        count+=1
# p. X0 h) i# |$ R( dfor循环
for count in range(3)  :
# {. r3 N5 {) k+ ]8 T, m) R    name = input('name: ')
! J/ i7 q; t2 A. z9 w. ^5 e) s% \    pwd = input('pwd: ')
2 `6 t' o$ O% R) U; c    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
! r1 G) `, M) d8 [% K6 g6 w/ G        print('error')
        count+=111、写代码
: C$ u% o8 ?: i: R1 p3 ?9 c2 Ma. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
% y: j  q5 V; k6 Y- ~0 o0 Tnum=0
while count<=100 :
/ d+ u' M( U- m" I9 {    if count % 2 ==0 :
/ v8 k+ }! t% h* {        num=count+num
        count+=1
    else:
- L5 m! h+ g- |1 |+ D( y- j% v        num=num-count
7 A" ^+ K: r+ k5 l; n+ s4 ?        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
& |; W4 z* L2 I0 v5 J num=0
* a! e- ?& Q$ U+ A" J* [. X+ {count=1
$ S. l" D1 ~5 w' Ofor count in range(100) :
, h- Z( F. s+ Z: X8 V1 l% b    if count % 2 == 0 :
        num=num - count
/ k+ L: |# v/ G. }* R    else :
9 o; c" P- U! a        num=num+count
* R. M9 `( }# r5 q. V$ ?: Gprint(num)

c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12

count=1
while count < 13 :
    if count !=6 :
        if count !=10 :
& z+ D/ M/ @; c9 f, g            print(count)

  {* J+ D2 H1 \1 e" D0 B    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
0 U$ z& u. c. c3 M( r% Mfor i in range(101) :
) t% Z4 M+ B/ ]9 h# d$ i7 @8 d    if i %2 != 0 :
+ j5 p' ^9 d7 c6 V) [* \        print(i)
% ~* L! h% m% D' v& W
- d# z5 x1 ]4 u/ e' o6 Ccount=0
while count<100 :
    if count %2 != 0 :
) C$ {2 K4 T. a        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
$ {! a% T5 A3 w0 k6 kfor i in range(100) :
6 F# N. n  U8 J; x0 \4 M! u# |( D    if i %2 == 0:
        print(i)
5 t* s- Z9 b. p
) ~- L: N* [; J/ N; c  x' [count=0
. h6 D5 m$ H( g7 Q# Mwhile count<100 :
' v" u0 a& O+ v' u1 f" [4 c    if count%2 == 0 :
" K) ]# ^7 l! @! n  l        print(count)
% k) P; p' d) Q! [& k+ O  o3 |    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
# r9 Q/ e& o# d$ K14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
, l6 d3 ~- M9 k17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
- m+ |0 b7 D5 V0 \print(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

9 B9 R0 r) J: b% I2 x/ l% T20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
# k8 p' k! W  T6 Z4 `
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
0 n1 H# i6 h& p" q: r( S+ @, C# g7 [print(name.startswith('al'))
5 `$ |. p7 ]8 G6 k) Y0 }0 b* Q. yc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
$ x8 c& G- a$ j* Od. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
4 v/ p1 ]* h% i& @: K6 v7 Zprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
& Z- n0 w- p9 M; a+ z- Tprint(name.split('e'))   ['al', 'x  ']  列表

1 V: X5 o( x/ i6 p+ x0 _% B5 Q8 lg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
) w' V7 K+ @" f+ h
8 r, U$ }; c, }8 j1 @: yj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
" `) @, m$ d' m0 t, e) u21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
5 x4 L4 q, z7 |  V依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
5 B9 x! j# N% kfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( X  S; r( W, u* U1 Lprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
; Y% U+ {6 O* W6 Dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
" e+ k& y. F# r+ t4 V" Me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 |5 c7 K# S/ {: K6 O# ^! ~li.pop(1)
print(li)    ['alex', 'rain']
1 J1 y. o2 V7 F  {1 D3 _" a! k指名道姓的删除li = ['alex', 'eric', 'rain']
! f! R1 r- u9 P2 L) A: gli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
* h9 G) r( ~0 k' |
, E& \8 ]+ d3 j+ [& H0 b+ @( Oeric
% J5 ^) n8 P, g) X1 ?9 n. H2 [['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 S+ w% M0 c9 b2 q* S8 Q1 F  t. Mdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
! j4 @* w# q! V1 \% S+ {for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& A$ ?& w8 y- `  u, Xa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
& ]; g) Y3 k! ~& l9 k  Vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
7 y# k9 v) v2 gli[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
8 s# i' Q4 A% ja. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 N1 @0 k8 h5 j- m* z$ @8 f/ B3 cprint(len(tu))
( w& n. Q+ V& Q  I1 @6 Ub. 获取元组的第 2 个元素，并输出
  g/ b& A8 o9 C3 D( S- R; M8 Zprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
7 a6 u9 O- _) K$ `2 N9 g; C10 alex
11 eric
2 o3 O0 ^$ ^( K3 A12 rain
& y2 O6 R3 Y( p( Q! p+ n$ v: c  d+ l! J
for k in enumerate(tu,10) :
9 b/ A8 K9 d- A7 G7 B    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')


9 X; z! @1 C# Q; O/ g# B25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
  N7 i) I( J0 [( @
* @% O7 a- P- h0 w7 Qprint(tu)
26、字典
, w) H' _* K7 Y, l" _! }& |dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
- V. O3 t4 f9 u8 _for i in dic:
( `$ Y2 L* \# k    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
7 p# H: M! X1 T5 U  ]print(i,dic)
% n( i/ D  I: Z* K) C+ A$ bd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: S. V9 N6 L, F! n9 |' D( }dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
4 @& }$ ?$ B' m5 Ldic['k3'].append(44)
. {6 \! ~) S4 Lprint(dic)
- _$ h+ u9 v. }' g7 S$ S: q+ ^
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 K+ G/ h! B* ?1 i8 e4 B5 idic['k3'].insert(0,44)
2 K. x6 O' @8 X( e3 pprint(dic)
/ c$ r; B# w, t) @, L$ {9 q27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
' U$ ^  l9 ~1 {9 F: N5 t; \  P
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
6 V* n) @# W2 V; Y) t* P" N) Aprint(tuple(s))

* y. r/ }9 t" a+ E( P; M% n- Qb. 将列表 li = ["alex", "seven"] 转换成元组
6 D. I. U0 ]! P& T0 ~( T" B. Lli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
! U( @- `1 [3 i* v" p4 {. C6 pli=list(tu)
# p  }5 p3 j( J1 \1 i' g. fprint(li)
+ u2 h8 d3 A1 w* n2 o& k# |  k# Z

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
$ u/ f5 d" u  i" A    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
* |! ^' f* z3 ja=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
: j/ c1 t7 C/ _1 o: Z4 xprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, y: k6 k/ v, U) l1 Vprint(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
8 H* f6 R9 _% Y' r2 i$ v  Wcount=1
sum=0
5 q; V" F1 ]" E* r1 G( c& lfor i in range(100) :
; Q/ V7 r- {# n5 Y* ?: P; Q    sum=sum+count
    count+=1
7 o: t& l2 x3 |5 zprint(sum)
7 Q$ r7 e0 E3 o* ~3 N
, a" {1 Q& @: \) g0 g+ \# \6 Mcount=1
% N% N- x% F% Q% V7 E% Z% ]; Tsum=0
while count<=100 :
" g! X' y9 D9 [4 r5 r$ n    sum+=count
    count+=1
. W1 x: b" i( _+ i1 u: Jprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
# I) F% T7 g* b% O& U将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- V; `0 I' [' S3 C' \' Y8 C" ~li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
' v. ~$ ?+ L: k7 g9 B0 x9 q- N) [}
  _' b5 h8 i$ c# j& gfor i in li :
$ Z# U  z& @. @* H1 e' e$ [    if i <66 :
$ v4 p! u+ {( r* d. q  q1 M        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)

4 s9 C; x" V8 E4 A$ b---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}