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

% u8 x4 G- ?4 X4 U, Y4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
' v3 J1 B5 x+ \2 k" V4 z' ^' K+ xprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
% h9 [2 ?. u, ]a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
$ k9 k7 ~3 n, H2 Sname=input('name:').strip()
  S0 B: d8 y; {0 Wpwd=input('pwd：').strip()
2 u" T( z! b, q! |9 W- i1 rif name=='seven' and pwd=='123' :
( z6 \: a2 ?7 [+ q) p" X& E2 i2 E9 Q% R    print('ok')
; f* G6 @, Z1 M) W, uelse:
    print('error')
9 Y" D0 r/ i. j- T7 j9 U+ E
# G3 P) ^2 _* @4 Ob.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
: W' n8 q5 O; F* f    pwd = input('pwd：').strip()
+ L3 e) `4 P$ Z/ W$ i" B& h
    if name=='seven' and pwd=='123' :
3 Y0 P% a( e$ c* v        print('ok')
    else:
1 `7 i+ A5 N2 J* ]$ [$ ]* p( K        print('error')
        count += 1
8 v6 p/ K! i1 I6 e. `$ pfor循环：
% l7 W& Q4 d3 U( _* ^$ e- d: Ufor count in range(3) :
7 u! t8 g3 s9 b" B: x* r5 V* Q/ [    name = input('name:').strip()
- {& v# z8 f5 h; A, o' k+ K( t    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
6 K+ Y$ X8 e2 n2 t& ~, qcount =1
; u8 e+ x9 J7 Q& c8 }- [while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
) [- q! j% _' M    else :
0 K7 `7 k+ g; B( S8 ~        print('error')
1 m; ]# t3 H$ N9 n        count+=1
for循环
; G3 s7 e# F1 k0 r+ ~- Mfor count in range(3)  :
9 Q7 O+ I% m3 B    name = input('name: ')
    pwd = input('pwd: ')
; W% `3 r3 o$ i8 k! ?    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; b, N) t/ \  a        print('ok')
% |+ T8 m& c1 {* P    else :
        print('error')
2 G2 K  X( K6 i) F0 G% I$ L) ?        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
( ~5 u) c) ^) J* r: _. Snum=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
+ R2 S% o- `  d- X& |    else:
        num=num-count
        count+=1
print(num)

* K' ?2 J, w- f3 O$ r2 W7 Sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
1 n2 a7 W5 D4 }. B, zfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
$ A0 ]! a/ S* t& [& R1 I: Cprint(num)

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

count=1
, q. I1 Y. |7 D& l+ c4 ~& i0 {3 awhile count < 13 :
( C( J' x% W. I7 k    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
; w; i  j% f# k9 b8 F" F8 r, _/ Afor i in range(101) :
    if i %2 != 0 :
        print(i)
' A# q# \8 n3 {$ d% _, T
$ N1 @( R$ V; S' z  ]4 K9 tcount=0
while count<100 :
9 ?* b, ?7 w" l4 V; Q* Z+ D    if count %2 != 0 :
        print(count)
$ P8 ^5 r: N" z5 O# C4 K. C- \    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ U1 n8 [# r4 D' M0 Z5 B0 R/ K    if i %2 == 0:
# T$ @4 B9 q7 ^1 F3 c        print(i)

count=0
while count<100 :
, O, M/ b6 F5 ]: U1 z% q    if count%2 == 0 :
' k0 O4 O( v* O+ A* M$ j% o        print(count)
    count+=1

/ }' ~' J$ T' N! M2 S" G; Q6 X2 P1 t12、分别书写数字 5，10，32，7 的二进制表示
4 R4 j) D! ~/ ^
' u4 {3 w5 o3 W2 V7 v, X- a2 Yprint(bin(5))二进制   0b101
5 |7 R' L3 `. ~2 F7 [1 U- r& G0 J- Fprint(hex(10))十六进制  0x5
7 T4 c/ \. m& e) ]' {7 w' Y4 [print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

. Z6 L* k) H; e9 j& H- R16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
7 A- o. \, ^) R$ U17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

+ M. y$ B" e8 F' x& H3 G6 x* W/ [! E18、布尔值分别有什么?

False .Ture ,或1  和0

: K, b" |8 d4 \8 A2 O9 Q5 f( t) C20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
$ ]' O1 |6 P0 ha. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
8 D0 m3 D( I: U0 }$ F9 \) O$ Y
, C% r# }3 b2 n  H; y3 kb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
4 V0 Z- |1 G' W0 b, {. xc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
" p1 }4 N! e' w& b  \& mprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
" X, @4 N+ U! _2 c% Aprint(name.split('e'))   ['al', 'x  ']  列表
% M, R0 Q! V9 D2 Y. {  w
5 U' p' y4 {0 e; E$ S- ?9 |g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
0 ^# z1 o4 {" f7 Z0 _' @8 G; m
) l) K6 O5 E4 h9 y8 ]) K) Pj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
% H) f2 {% r, ^1 W4 o4 E- Qname = "Alex  "
2 A" U! v2 `! {4 ]* H; z9 w8 Rfor i in range(len(name)) :
    print(name)
for 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']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
* o! R1 W  x8 D8 V, E- }4 L& bprint(li)
['alex', 'eric', 'rain', 'seven']
) v2 Q' J( j! v% p% W$ sc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# O; Q( b6 K- r0 X7 w/ {print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
. }/ J" i; t. L9 k5 p9 Sprint(li)
( g9 o& r. R" d( C2 ~/ O/ r" tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
; u+ Q  q' K/ tprint(li)

eric
4 Z" B* g  J' b" s$ f['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
' S/ n$ {7 f9 adel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
9 S8 `; [+ B& b/ }2 r& Jli = ['alex', 'eric', 'rain']
! j) G* }& {+ @for k,v in enumerate(li,1):
3 D/ C* D/ v' n- N: ]    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, f' i: X) N6 n$ j, Ya. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 S; B8 E( M- e' l! Z0 h# Vprint(li[2][1][1])
- t! u. T; V/ O% Y. wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
3 f; x3 J4 T$ f+ J' H1 [; nli[2][2]='ALL'
* f! \2 l' ^, }0 _. g" Bprint(li)
; `6 u( A; y) w3 N* g: e; a3 Y5 Q" O& W24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
" l' l# u0 Y+ V5 A4 [0 T5 i$ Ka. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& f0 |/ K8 A3 W! L: u' I8 @print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
5 u% x; u- z6 P0 Sfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
% C) F0 Y$ W" w10 alex
11 eric
2 D" B% E" t$ w12 rain
' {+ y8 A: T; F2 G0 \. U
! N8 y9 J7 b, U$ c: j/ ^for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
; Q* ~0 \. _$ x2 `1 s(11, 'eric')
(12, 'rain')
; P- H6 k1 X( I! M5 D

25、有如下变量，请实现要求的功能
% a3 f4 j7 r; E. S6 ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: N5 T+ t4 q) ^. }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 Q/ E: L- H" S" f6 nres=tu[1][2]['k2'].append('seven')

4 `! A% {& T6 m; u7 O0 Vprint(tu)
9 L# W0 D- J! U' ^" r0 d26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
. `9 `3 p: L* ~/ k$ g, E    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
" d  _4 b+ F( F3 C# B- |' Tprint(dic)
" l- l- F/ ^) @8 |7 X# @e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
9 b: X% s6 z7 E0 hdic['k1']='alex'
/ T" R0 P7 r! n' C& h! ~print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( y% T% X/ D. @/ mdic['k3'].append(44)
, v, \1 W$ `( c* g# hprint(dic)
" D+ g' [; n" @: n
0 E8 b; G) H/ {- \3 Ng. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
+ }% E# x( |7 ^/ i3 s; Fprint(dic)
27、转换
4 ~4 H, F& K# s* l# p) O9 [* D# va. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
3 f/ ?8 p7 c3 ^+ X0 \; |* oprint(tuple(s))

' x" L( r' a* o3 z* l/ `$ q, h( Jb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
# z- [/ w9 I1 e. P6 _  c: R9 lprint(li)
9 x  Q4 R, s* r$ I; N7 K# f
4 ?& U$ Y; w; c; ^* {2 x
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& f! [5 r) g# X% R
dic={}
" q: M4 P0 U9 g0 W0 ~for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
; f0 p( M  Q: z2 u    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
4 [, [4 S5 Q. dprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
( \' \0 w/ o( r: i7 V  y5 Cb=a.decode('gbk')
6 ?( p! P) O+ i6 r  `print(b)28、求 1-100 内的所有数的和
2 \3 R9 M3 t  Icount=1
. L* i' l/ F1 r- {! z9 l. Esum=0
for i in range(100) :
7 L4 D& n' Y: ~. i3 y8 y    sum=sum+count
    count+=1
+ y# Y6 _0 {- P% Y  Z) r) a/ Eprint(sum)
5 `, X6 e9 Y) o( C. R1 O* j
, j% ]: W8 ?# ?count=1
" v* o; v1 A2 j0 V# msum=0
while count<=100 :
5 G# h0 w2 C# C) q) {- U    sum+=count
    count+=1
! T1 ?& s& h3 ]+ u% n" z( Z( N+ P) mprint(sum)29、元素分类
2 o8 Z, ~! N; N1 K4 |# j# `有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
" L5 n* D. |7 W. R, x将小于 66 的值保存至第二个 key 的值中。
* x. v, ]8 |9 u/ ~即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
0 Q1 k. p2 w& `; T! Wdic1={
    'max':[],
0 m) p3 R5 g. h) Q    'min':[]
}
for i in li :
    if i <66 :
% L! H8 Q3 q. L. I        dic1['min'].append(i)
    else:
/ x: M2 n( z8 m: o" c  z        dic1['max'].append(i)
; Z' q6 {6 i+ m7 Z! R2 R% X# [print(dic1)
5 h$ p; [: ?" W7 i- R" Z$ }
5 _% O  Y4 X: _( G1 M# Z8 w  P6 S( d---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
, J5 w  Y+ l# k" t2 U- A! T) P# b