Python基础知识汇总

1.执行脚本的两种方式

Python a.py     直接调用Python解释器执行文件

chomd +x a.py   ./a.py    #修改a.py文件的属性，为可执行，在用  ./  执行a.py 文件

2、简述位、字节的关系

1bytes=8bit  ,2**8=256,可以代表256中变化，

1 u- C" U, g$ E0 z3、简述 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

1 A% {& x# e/ C: b$ ^. u5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

- K6 d( V' ^  [1 Z8 E. a. w6 a& b8、如何查看变量在内存中的地址?
9 F0 h$ k. ]( u( Z& j; O$ K3 _z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
# J* \% M- ?$ \& Q* v( Wpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
5 j8 F% `- d5 W    print('ok')
3 b8 U# z' P7 l0 s2 aelse:
; @9 ?* j2 S8 }" F% O6 a6 R) `    print('error')
9 }5 K3 [0 A$ q: ]5 e: v( N
5 \. y9 ]) X% rb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
& B* ^; {) I( _    name = input('name:').strip()
    pwd = input('pwd：').strip()
+ @& N) c+ I+ }# l6 t$ n
    if name=='seven' and pwd=='123' :
- l, s2 _4 J. j        print('ok')
& D0 J* [: w! W4 d& o" c1 [1 A; d    else:
        print('error')
  j1 M5 `# r* S/ V4 g' l        count += 1
+ Z7 d$ o2 e' U- W( b) G2 x, ~; ifor循环：
for count in range(3) :
5 X5 _7 {, I" \& P    name = input('name:').strip()
    pwd = input('pwd：').strip()
2 e. j3 |( p1 z$ x- ]
0 M" m' B/ g( R( B  W2 `! M- e    if name=='seven' and pwd=='123' :
% @' H. b( c& `9 p. I1 K        print('ok')
    else:
        print('error')
% [2 T4 a& r& E$ s- g        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
: x6 g$ Y* g8 F. W& K    name = input('name: ')
5 T1 F$ \# u2 B    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=1
for循环
" C7 R2 }; j& q0 `; i& Ifor count in range(3)  :
- [& m% L4 Q5 ?1 p8 Y' Y* X    name = input('name: ')
$ a8 |6 {2 Y0 `+ D    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 e' S1 h) |/ t  z0 n/ c( {        print('ok')
    else :
6 H: X. }/ o8 L6 F% h3 i  G        print('error')
  O9 z6 t# t8 K( J1 Q5 \8 ]/ K  R        count+=111、写代码
% G% D8 y8 X" G# k  \; La. 使用while循环实现输出2-3+4-5+6...+100 的和
* @$ i% {; e  }: `6 _9 h. z) Hcount=2
num=0
while count<=100 :
    if count % 2 ==0 :
1 q. s$ L3 m# R9 j        num=count+num
# z. ]' @$ E! K, P- L$ g/ B        count+=1
- X/ K- R# O) K5 O1 Z* ~  \: S    else:
9 J8 u2 |% N: F3 t/ A8 S3 H8 P        num=num-count
        count+=1
print(num)
  u9 M( ^- O5 g9 t. j& {' R; f
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
6 ]0 |  ~, J/ b6 L& k3 P    if count % 2 == 0 :
        num=num - count
    else :
% D; {# K: B5 l( h1 C% U7 x3 w        num=num+count
print(num)

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

0 ?1 [, a8 {4 y' _& Zcount=1
while count < 13 :
" m) c1 b4 q# U! {    if count !=6 :
        if count !=10 :
            print(count)
: e0 [& S) T2 D  I% b1 I
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
5 A, g; w/ w! G9 \    if i %2 != 0 :
* |# ?; I% o0 j, u/ F2 [3 D" z: r        print(i)

count=0
while count<100 :
    if count %2 != 0 :
. a6 h. u3 X1 G+ ^1 ?' A9 D        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
2 _% c! c- e- V6 L( J# z: B        print(i)

7 e( w  ^2 a3 [" ~8 y' Q5 _count=0
while count<100 :
! K* V9 `9 ~& E. ?+ f5 R( q2 H' J    if count%2 == 0 :
        print(count)
; n. b  v& L* m1 _& o0 i    count+=1

0 L2 _( ~) T# x# U! K12、分别书写数字 5，10，32，7 的二进制表示
9 ?% _/ j' S. v! e, i
print(bin(5))二进制   0b101
" W4 o" G7 k$ f9 s( K$ dprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
% O0 f- P5 p  n( p* C* Q! u, @14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
4 x; L+ P: N' f: C- P8 Z8 @print(int.bit_length(n1))  结果  3

" d! ]( C2 S& ~6 }
18、布尔值分别有什么?

False .Ture ,或1  和0

3 e/ a0 C: g& Q9 g" j5 |1 K' J# S5 B20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
  p  W8 u  \  b& x$ j. V8 }
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
9 [8 E! ]3 o& iprint(name.startswith('al'))
5 G% N% @9 R* B% V; D. Q) kc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
# h, V( x# y$ T+ ?# n0 Td. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
1 D' _* ~1 B% r) a& P6 |/ V  iprint(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])
5 U$ R  A7 v6 y# ~
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
. C# w3 H: V5 x7 Nname = "Alex  "
for i in range(len(name)) :
9 m% T9 ^" |7 G( s8 \/ I) k    print(name)
for i in name:
7 _! B  l1 `% O1 v/ B    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
$ V/ O* D1 R3 ]9 U22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' W4 t  W; b. C+ Qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
, ]) s  l) s* H$ aprint(li)
['alex', 'eric', 'rain', 'seven']
0 w4 Z' m  k0 S0 y! q3 {# ~/ Nc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
' u$ `; r, `( _4 ~li.pop(1)
0 l  G' A9 {2 S. @; |/ Kprint(li)    ['alex', 'rain']
/ _0 ~/ h. H2 Q- B3 R" W4 i指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# f0 C9 z, U  I2 `+ R, y# oprint(li.pop(1))
print(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
; t- x. y3 Q7 {0 H" z) [  F7 Eprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 y0 E' ~. i& s: \2 p5 X$ kli = ['alex', 'eric', 'rain']
' _) Y$ K+ \! l+ Y$ _for k,v in enumerate(li,1):
) d* `& h0 T" y: Z! g% C    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ @  [8 z4 B0 h0 N5 a6 f! kprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
4 F1 I. h7 ]# B4 s$ Tprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; Z- ~5 ]5 S; O# _) Wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
- W) o: o; T8 }3 ]5 Nb. 获取元组的第 2 个元素，并输出
print(tu[1])
* @4 B1 n( H5 j+ G4 e/ oe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
+ Z' i, X4 y' }  x7 E8 E& G/ F    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
4 ^/ t2 p* |' Y: k7 C) h) j$ jfor k,v in enumerate(tu,10) :
/ _# a, N+ P$ \0 `& s8 P6 a* ?    print(k,v)
- o8 w6 E, w) j" D! v/ }: Z$ g10 alex
11 eric
12 rain
! u$ s9 d8 K6 _5 E
9 ~' {8 n$ u* |+ r: m; h: H& tfor k in enumerate(tu,10) :
; h9 p4 O8 w0 K& y: i6 G6 @    print(k)
+ A1 B* h! ?! f- P(10, 'alex')
2 e5 ?% H3 S9 _$ Y  F% B. X2 x/ T(11, 'eric')
2 a  i. E5 P) ?$ h(12, 'rain')
6 [9 ~8 ]  I/ G+ J6 o  ?$ k

$ o/ U3 N' N8 ]' c; r$ k# V25、有如下变量，请实现要求的功能
- Z6 W! r( D! W5 o+ ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
! f7 {7 g$ D& W# x+ _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! a) b% b% D0 e- @6 e( [2 v6 ures=tu[1][2]['k2'].append('seven')
" ]8 a5 r9 P$ n5 F, A
print(tu)
! k! ~: D% m* P1 Y26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
6 f, G+ x; c, n- ~- ad. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) X, R" X+ z) _. u1 c: g7 @1 adic['k4']='v4'
! @$ _' T4 J, g5 `% ^: I8 n- ^print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
2 ]1 d4 y/ n' xprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
% y. _: ^7 ]1 O& [: t
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
# @8 T3 H% ]' ~5 E3 N# d+ d8 S( xprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
4 `& w9 ?% O0 dprint(tuple(s))

' \* A3 I. K6 k" D9 ib. 将列表 li = ["alex", "seven"] 转换成元组
; _% h' B- r7 m. ?li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
/ p; P3 p$ A# Z# P6 U/ U# Tli=list(tu)
print(li)
: l5 Q4 L. l; y* b! m+ U; ]! H( {

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
8 y# ~% \$ u& P6 s8 j' L$ V
0 q# {. A( I; B) i" Fdic={}
# X2 K5 J2 j# U$ E6 xfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
$ l. i, i5 p0 y. \7 v    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
$ I- f/ \2 H; _  Ma=n.encode('utf-8')   
print(a)
) D/ u7 L6 n. L: N" M* Y& rb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
. D6 ~# P7 ?6 T& L2 z4 B& \7 zb=a.decode('gbk')
$ ^  o2 N8 P7 Y) h& zprint(b)28、求 1-100 内的所有数的和
8 G, y4 |' C0 d  U- V" u  g7 ]  gcount=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
3 d0 y5 q) j$ G' D  W7 l
0 b$ R! Z& @$ Z; x" Q9 Icount=1
" L) @$ ^; p3 }, `1 {) vsum=0
while count<=100 :
  H; p, l* v/ E1 W; W2 {$ |/ y5 o0 c    sum+=count
    count+=1
print(sum)29、元素分类
1 p; g+ `9 A' S+ T+ u有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
; A. h9 c7 N) O. e% W8 j即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
$ x0 c  t9 h; N4 k: D: jli=[11,22,33,44,55,66,77,88,99,90]
7 G- I5 M) A0 ^  X6 _9 i0 \dic1={
    'max':[],
    'min':[]
}
8 }$ K9 i* t6 W% d5 V! u, Xfor i in li :
    if i <66 :
- |. Q# h# s* q/ c& U$ s( H0 a# n5 Y        dic1['min'].append(i)
% S/ y* |+ ^# Y( c% Y2 B" c+ \9 h    else:
        dic1['max'].append(i)
& q, m( y, F. i8 t5 Gprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}