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

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

单行注释  #

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

. T/ U' n7 M! t' B7 m6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

- K( c& y( ]7 e: H2 \8、如何查看变量在内存中的地址?
z=1
print(id(z))
! [% B! u; t0 g6 k% q9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
  f6 e) q( J. b2 f+ `pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
3 \% q  w2 X6 F9 m    print('error')
5 X7 _4 v4 A7 [, i9 M
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
7 ]: P7 m% I6 y4 ccount=1
' T. B7 C# J( |8 y5 p, kwhile count<=3 :
    name = input('name:').strip()
& g0 {/ Y2 s+ u( z    pwd = input('pwd：').strip()

. [, B- [4 u2 z9 B9 Q    if name=='seven' and pwd=='123' :
3 h4 f" R) ^" x$ s) g* J0 o$ y: ^        print('ok')
' o# z0 l/ m' H% Z) K' k    else:
        print('error')
        count += 1
for循环：
; S) Z8 t6 m2 u0 J2 ffor count in range(3) :
$ v3 A7 o3 c7 p& N2 d1 l    name = input('name:').strip()
4 X3 x, i% B* j  J: W+ B4 a    pwd = input('pwd：').strip()

- Y% f4 z2 L. T+ u) B    if name=='seven' and pwd=='123' :
        print('ok')
    else:
) u* K% C- H9 v  ^. @9 N# W        print('error')
1 \6 g& e! L0 {2 N2 l% k        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
0 u0 r4 f( O- ^2 @count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
/ d' E( E+ O2 t+ i4 _    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=1
+ ~5 r$ W/ W' C5 C6 E6 {: b" vfor循环
" ~' q5 C4 T0 G6 B4 j* Rfor count in range(3)  :
% f" s/ X: t) g  ^5 [& |    name = input('name: ')
* G8 j3 T# M& ?# m    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
! T: _- Y. K* e. ?* o        print('ok')
    else :
! I# O1 ~6 U, u4 ~3 }        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
2 S2 j! e6 ^3 d7 c" W! j+ gnum=0
/ U: v9 a/ f) `0 s7 Z6 ?# dwhile count<=100 :
    if count % 2 ==0 :
$ m3 u) X, T9 I2 Z        num=count+num
% b7 b; i; x* R4 n        count+=1
% K: Y' N; k2 k    else:
        num=num-count
5 ^+ z% B% Y$ t) V8 L/ o        count+=1
: m  Q+ ^5 V* _* l2 ]1 s- C2 ?- iprint(num)
  H0 @4 R5 c' ^
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
- j1 k% j0 ^" J7 ^1 [    else :
0 f$ t3 P7 t' V6 V: e        num=num+count
print(num)

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

) S$ a9 \( s- Q  F2 y" f1 E. [5 j3 Gcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

+ x  \7 p) X1 Z  S# F    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
# V$ h5 a7 E) X) c% t4 }0 l        print(i)

count=0
* l/ G5 _1 _8 I  E9 Cwhile count<100 :
    if count %2 != 0 :
8 R! |" _5 d' @5 Z        print(count)
" w% U$ O/ R9 K* w# v0 B0 P- S    count += 1
7 x/ B3 A3 S* R" b9 d6 [" ?
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
6 n2 T" x, b3 P& R5 G7 e0 t
' G8 `8 T6 o7 v2 r+ Mcount=0
& |. ~* H7 k; j! |1 V$ M4 d+ Fwhile count<100 :
4 ^! Q- X" M6 {8 c+ Q* h0 {$ G1 E    if count%2 == 0 :
        print(count)
    count+=1

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

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
) Y4 |. \6 v5 K. y  q( T) Rprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

18、布尔值分别有什么?

False .Ture ,或1  和0

9 Z- Y8 T+ A+ S20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
/ |# a- ?: U2 M) u+ c/ L! V8 i4 oa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
& V- U1 ?( E- m/ L2 y: ?, a
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
: q6 C: G$ T" a; H# \; B9 r' wprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
1 C% V$ p0 L. \print(name.split('e'))   ['al', 'x  ']  列表
& s% W* }0 [6 y1 s# U
3 v, C- G! o( ~: V9 n% N. Ig. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
4 f+ D" i1 I6 M# m4 ?4 E
1 J" S1 d/ [' _' k" Vj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
* L1 v% W. I6 x! \/ ?依赖索引
name = "Alex  "
+ f; `) _, f6 P) R. ?for i in range(len(name)) :
/ H2 E1 }( |8 Z* o    print(name)
5 @2 H2 a2 s4 o7 n- V4 d( Dfor i in name:
( Z2 a5 M( v9 W5 a7 E    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
( g1 @( Z# a+ l3 R: J22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
2 ?% c6 U8 G5 cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
" L& T. g0 |' Dprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
6 K5 @0 L( a2 r0 l$ d3 }print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 O4 u; i& K# G+ B. O7 \8 ^! rli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
, V  d5 t( \7 F. Qprint(li)
" S% w- m2 y6 K2 m6 Tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ t2 e5 f1 H* |% Z. ?% Z; yprint(li.pop(1))
6 r6 K7 b" K5 g/ y2 Uprint(li)

) }5 Z" L" R/ D0 ueric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
4 G1 G2 _  f! y! ], n' sdel li[1:]
( f' |4 b& R% E5 [print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
9 W+ G/ ]2 X4 n3 ?# f; X3 Qfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- h' I3 j% b0 t4 x& ~a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) V4 {7 }- h7 k, V, ?print(li[2][1][1])
2 ~8 v) @# C3 F6 Ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
" W+ O" r. {, P: p  d. i' Hli[2][2]='ALL'
* p% O- F  Q3 S+ K$ s, Dprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
' ^# O  Q6 `  F  u) x' ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
9 H$ s6 I7 x9 U# i! lb. 获取元组的第 2 个元素，并输出
4 L/ d& Z! d, dprint(tu[1])
! \1 x9 ~$ G0 Q0 ]  }+ [7 G  N( Ee. 请使用 for、len、range 输出元组的索引
8 v0 O  @$ ~, R$ P6 `0 A8 vfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
/ Y) U/ Y) q# N- R/ y+ D. b% y10 alex
: D( S7 j6 J& ]0 n11 eric
12 rain
6 D* ^% S3 O/ |" r: X- l, E
9 v) s+ `2 |4 S4 rfor k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')


* N$ V8 _0 ]: ]; v7 i+ i8 }/ T9 ]25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

& W3 |7 a) h* l4 G5 c7 ^9 ^- a! ~d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: J6 h5 i& q, Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
+ m0 _9 V) V, a  M1 {26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 F9 e. n- X9 l( g# k: u# W    print(i)b. 请循环输出所有的 value
for i in dic:
; x( s* c& X6 h/ Q' s, v    print(dic)
! P5 j* ~) X# Q, R6 c; H9 Vc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
3 h6 H; \, J3 D3 ?2 V$ {& kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 V( ^3 N( |  I2 R4 ]3 Wdic['k4']='v4'
print(dic)
; e4 l7 ~4 \, c2 X+ c" O0 G* ie. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
! S3 E7 t, y( ^- [0 E0 rdic['k1']='alex'
& A9 {& B' k% ]/ Zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
; S7 M5 K2 O5 fprint(dic)
# ^/ V- n+ G" ~8 \
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' d* \6 P: L* W8 j" Rdic['k3'].insert(0,44)
3 E3 K$ F  K5 a8 R' s* }* Oprint(dic)
27、转换
8 x" S# H4 \' pa. 将字符串 s = "alex" 转换成列表  s = "alex"
3 `2 u0 K4 m! a
5 t- a/ X, J) X: n8 I% u# uprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
3 V" E8 O* w8 w. P# J# @; ~
b. 将列表 li = ["alex", "seven"] 转换成元组
" P' v) Z- l2 ^, J$ w" S) lli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)

; O; Q! i; ]& _2 S( N7 ~+ q5 M
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 C' C6 ~' M7 ~! _
0 o+ ^. M8 k6 Z& Q6 Udic={}
2 H" k/ n! e" afor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
& b9 `- h& _, z4 v) I; i+ K    print(dic)27、转码n = "老男孩"
, c- [& v8 H5 qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( a5 i1 `' W4 j# ra=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
/ ^! O! R; \& k5 D( P( Z- I( p/ G, Aprint(b)
+ M. i. C. t0 w( U/ l/ o! ?b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
/ N! N1 {2 v& W) L" Vcount=1
: a1 C' Y; s2 w1 ~- xsum=0
/ `1 ^  |% V& ^/ {2 t3 Tfor i in range(100) :
% j& f- `$ p0 u2 {+ D    sum=sum+count
    count+=1
print(sum)

/ y6 p6 Y  S" l& \# t6 C4 v6 Ycount=1
# n- q% S2 W8 \0 F+ wsum=0
while count<=100 :
9 V% `% _1 n; [- s! H    sum+=count
# f4 t, T4 x- I0 y+ z    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ Z1 ^6 N, [) P; t- z3 B5 c  N将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
% w* ?4 U4 q6 [& ^( T    'min':[]
. A$ j) h$ T& X8 b}
  C# d, G% v7 Dfor i in li :
2 ?0 l# w$ {7 B. @  a9 j( G& P    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
6 s9 q; [( j( o& ^+ fprint(dic1)

, o  B1 a+ k6 z% p---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) @. y/ \) i) v