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个字节代表一个字符，

, A3 C1 n: p; H" S, Y9 a; G  S4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

2 J5 h) V3 _/ Q9 ~8 W  |1 w! A5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

" G- ~" \2 A# N) ~8、如何查看变量在内存中的地址?
! N4 ?5 T9 @8 J, w$ u# Fz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
3 I: O2 ?0 Z! s& U1 M. va.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
! e( E  ~0 `/ Z  x- g% jname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
* U4 l  W, Z  x* k, u: t+ i9 r1 celse:
3 ?9 T- S; ~7 Z    print('error')

( s% C0 r/ r  [5 E$ w  pb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
( t# e; m7 |* r, h% f    name = input('name:').strip()
    pwd = input('pwd：').strip()
* b" q) ~% k+ V' T+ Y' k$ O2 q
    if name=='seven' and pwd=='123' :
; I( A4 J3 Y9 I2 ~' @        print('ok')
    else:
        print('error')
        count += 1
1 b1 Y% z4 G4 c7 Z  rfor循环：
for count in range(3) :
5 I. O' Q& I: G# d( C9 e' B1 [2 y    name = input('name:').strip()
    pwd = input('pwd：').strip()

+ I: y( O0 X2 F    if name=='seven' and pwd=='123' :
        print('ok')
4 g; D/ S  r6 O% s4 ?" w    else:
/ h5 Z5 M& N# E        print('error')
& e4 ?$ N+ @2 N5 m, X        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
9 m9 z2 }1 Q3 x$ ~9 P6 V' _while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
) m! W3 D( u7 n4 X' D# b    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
- Y2 I2 |; G2 s9 z3 @$ e        count+=1
$ f% }* W* L1 H" X  w7 P% P$ Tfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
: d5 \; Y9 @4 q    else :
        print('error')
2 e; k! U& s1 x" S5 g) ~        count+=111、写代码
) A  z% s7 i- E$ G1 s3 [a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
6 i0 a( S" H. w8 T: inum=0
1 x' p9 }2 P, U! Iwhile count<=100 :
6 Y) W  _) ~/ G0 X: z    if count % 2 ==0 :
% H  |$ |8 M$ A6 _) c( a. T        num=count+num
" Z$ [+ K; u( i0 E, p. H) O        count+=1
; p* d) b# ~+ h  I2 c    else:
        num=num-count
4 _5 ^- ?0 x" O3 H2 h% V        count+=1
6 V% ]/ G' ^: e2 J0 I' }) Jprint(num)
6 ]! u1 D0 [3 [) d% A
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
* S" P) q9 E0 j( U: j# _count=1
for count in range(100) :
- d$ i6 \$ x- {, g0 B% d) k2 i    if count % 2 == 0 :
        num=num - count
9 y9 o8 m! q- _    else :
9 e% ~- [% s! b9 I) |        num=num+count
print(num)

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

count=1
/ ?8 h! p1 ~& k  awhile count < 13 :
! m8 j& I; ^# z2 F    if count !=6 :
        if count !=10 :
! S* G# r  ?! g- i0 t6 _9 S- N            print(count)
0 Q- F3 Z2 v0 c5 l
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
) a: o# U3 B: h3 H; Ffor i in range(101) :
    if i %2 != 0 :
        print(i)
( `- K3 e; Y- x5 o# y' s
count=0
while count<100 :
, n5 H7 T, d% L    if count %2 != 0 :
2 `5 Y$ e, ~0 h+ Z3 I: O        print(count)
    count += 1
- G+ d. ]) R/ f' x" |6 k9 R6 {
  [. [" O5 X8 @/ s0 oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
/ ]( f1 Z8 y5 P2 A2 c, A0 w7 q        print(i)
. Z8 x8 `' n" s3 T( k
0 g1 c/ u" g5 R) L- O; [count=0
3 U$ b9 N1 K% U$ Uwhile count<100 :
+ a$ }- b( P9 O$ K; T9 L    if count%2 == 0 :
8 M, `) Z" @. y. E" M4 ~        print(count)
    count+=1

; L+ G3 f7 ?' v" B2 R4 y12、分别书写数字 5，10，32，7 的二进制表示
! \% M$ l* X( \/ v- H. x
* C! M# W) u3 ]' p0 tprint(bin(5))二进制   0b101
/ s0 F5 F1 `! M" C0 ]" [# A% Dprint(hex(10))十六进制  0x5
" n5 F; d& `/ _" `" H0 }print(oct(5))  八进制  0o5
" X1 L; Y5 }; M6 E/ w9 o14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

5 Z" f8 o/ B% S, {1 |16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
8 x. L- T1 p$ ?17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1))  结果  3

3 K  Q6 n; X7 y% F  d. R& D( u18、布尔值分别有什么?

False .Ture ,或1  和0

. i' }  @  S5 M+ P" b3 u20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
) G$ }6 k, }8 ~3 }! ?a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

2 k5 |! O& P3 Tb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
% f7 B5 H' E* kprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
! @5 s' a( [, F; T' m) n$ sprint(name.replace('l','p'))   apex  
! k( k& v- c# {5 V& @% ]8 [/ Le. 将 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'))
9 N# F1 P, r5 W! i21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
& u" o3 }" |9 G5 S: M4 C" F    print(name)
for i in name:
0 u0 K  n  w. V  B- Q- s5 L    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- C' A# j. n0 B. _5 w: \5 l1 f. cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
6 f  B2 I2 P" U: b1 ~print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
/ _$ R; N) d+ l1 ]/ xli.pop(1)
% P! z1 Y- @: E9 M; n5 O- X% ^print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
2 n) x6 y  R5 Yli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
/ A7 m& e: v2 z  Q3 g, E
eric
* }2 L* ?6 m* m- O* ]( o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
+ S  K; D1 K) ?print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
5 d0 n6 a! M5 n; Y; S7 U" g7 u& xli = ['alex', 'eric', 'rain']
4 F- \5 G! S3 P$ i% e* V: Efor k,v in enumerate(li,1):
; Z6 H9 P4 B" I$ Y1 ~    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
0 c! C4 |' \0 q- x& X& X, dli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 s7 \7 m/ ^0 D. [print(li[2][1][1])
5 \* ?/ u) R0 {& U. Kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
+ v) @! K  t1 k9 D& zli[2][2]='ALL'
: Y. x/ A6 `2 rprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
8 p) x5 b) J, Fprint(len(tu))
( V2 J  J: @- z4 e& N4 Gb. 获取元组的第 2 个元素，并输出
" s  G+ E5 z6 g2 Hprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
" q4 n8 Q) }" N& F# W4 g    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
! y6 H1 u+ v8 v  k    print(k,v)
$ j* k' m$ J# `0 [10 alex
11 eric
12 rain
+ z3 S; N  Y$ r2 w1 P
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')

, |: _2 ?6 R" C3 S% I' w) R1 T; V8 Q
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

/ m0 ^, x! |+ g2 Z2 G! dd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 u  F. K! w; Ures=tu[1][2]['k2'].append('seven')
- G* d0 ]. M$ y, R  ]" T0 n% k
! K9 T# g! B3 U. H4 `' y3 T. _print(tu)
3 C! A2 a: Q2 p* w7 s/ l26、字典
/ Z8 n& r& B5 Q2 y% ldic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
0 t7 r  q, Y4 f( efor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
$ B8 @' N: ], v7 Zd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
- s  b5 V. c: [6 mdic['k1']='alex'
. Q# S. e% m6 X8 x" Zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
% A7 w, H# \, A5 d+ W3 C- g( K3 vdic['k3'].append(44)
( @7 e6 k! {3 bprint(dic)
) g; T" n  Y; f/ I) M, W3 k! @
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
+ s% e8 G) X4 @( O: d8 ma. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 j5 T& |/ ~1 xs = "alex"
; P7 u. v7 G6 V8 [/ Z4 oprint(tuple(s))
1 R" d9 x/ c' Z
/ y0 Z0 P, m7 D' ?! H$ c6 wb. 将列表 li = ["alex", "seven"] 转换成元组
. \9 b7 j( X( ?9 d6 q# @2 cli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ x/ t# n0 k0 q, V5 Ltu = ('Alex', "seven")
- t4 P+ {7 W* uli=list(tu)
print(li)
" R; S0 \9 S0 b9 C
# f. x1 Q1 o- e& H& {
+ }/ I7 y" V# S# hd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
1 g% h% m5 V/ f' T
; y5 a' O1 u( ?+ j$ M! mdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
; U# e  T* h: B; v    dic[k]=v
; \5 o+ Y% u& n- O, ^  q    print(dic)27、转码n = "老男孩"
0 f8 E5 r4 Q$ n# q0 Y% L+ \a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) P' A) U0 a/ W1 h$ b8 K! Ia=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
* _) b5 D5 I; F' I6 f/ kprint(a)
2 V2 `6 s$ t: v6 a4 |/ w! q! k9 Ab=a.decode('gbk')
3 B- d: w5 ~& q4 p0 @print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
& y- I# M7 w6 Z5 s' t    count+=1
print(sum)
2 w8 K0 w2 x  ~2 l
count=1
sum=0
8 E6 i4 L" B7 R5 x# Y/ N. @while count<=100 :
    sum+=count
    count+=1
print(sum)29、元素分类
1 K# B. w$ s7 Y$ ^& x) X有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
* B2 R$ _7 j4 [; q! D将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
% `/ D  V# k- n7 V1 _5 eli=[11,22,33,44,55,66,77,88,99,90]
9 Y) D+ \9 B& e  C7 z( y9 xdic1={
% u: @) V5 V1 h5 S- j5 r    'max':[],
    'min':[]
}
for i in li :
    if i <66 :
' P3 N% o( P& b% V/ [        dic1['min'].append(i)
    else:
  N1 U# u$ m6 {- k5 I8 k        dic1['max'].append(i)
print(dic1)
( _  V+ n$ n% |# ^' V) `' g) G) C: E
5 p) k1 `" d4 W. j---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
- \5 p' i" F* X' S7 N