Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

2 \3 N1 e+ U' V* a# S) t3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

( {. L( {+ Q9 X2 N/ [2 m( _6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

6 q5 s. H4 |) F" ^: j: k8、如何查看变量在内存中的地址?
3 T4 w, Q" r$ J1 k2 p' V+ Pz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

' a, Y! `, ^; f  [9 \10、写代码
! o* O8 N) S2 a) ]# [- A. ]a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
. u$ D: R6 T5 P. M$ k3 ~1 P. ^pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
5 B7 o0 x( [% e- H3 D6 Felse:
2 x2 Z1 c- |3 Z! }6 L" _3 l7 g9 g$ f    print('error')
4 K! s7 W1 W+ Z) Q' E
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
& y5 {& U( ]8 r$ E) C) L4 \# W    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
9 q; v  R8 P" T# j        print('error')
& G2 J( s6 \6 a$ k6 A1 s+ n        count += 1
4 F2 Y. D! ?! M/ J+ }( Yfor循环：
for count in range(3) :
5 |, I6 A0 X" }& e    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
- J. h4 Z; m  ?: @" t; H    else:
1 v0 F& Y' a; M2 Y( J: a        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
) ]% T8 ?1 C8 J4 T    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
  y* q5 `4 c) ~        count+=1
for循环
for count in range(3)  :
  F3 b  _( t9 u$ C% o0 s8 W    name = input('name: ')
    pwd = input('pwd: ')
' _# H" p  l. c5 N$ ?! x0 _    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 ?; F; _# P) A0 e2 `+ i1 y* P, q        print('ok')
    else :
$ S: K4 k6 ^4 d6 T0 e4 [  ^        print('error')
        count+=111、写代码
# `; ~/ ~6 d0 N2 r3 `5 ea. 使用while循环实现输出2-3+4-5+6...+100 的和
, v; v( q2 j! M4 t& Vcount=2
num=0
while count<=100 :
$ J+ K9 X, s2 g' |    if count % 2 ==0 :
# \% |6 B. [' _* }% T# T        num=count+num
        count+=1
    else:
        num=num-count
9 Z# L4 g/ w- b! m+ o        count+=1
print(num)

& ^7 G! s7 W% w0 ?! M8 kb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
" ^2 x8 J4 b2 V* Y: z# \2 J2 q num=0
0 t( L9 R! Y, u: b3 o& D2 d5 r" Y: rcount=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
- `! {) l$ ]  y8 ^# m5 {$ vprint(num)

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

7 B1 P2 _. L, u) mcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
* R1 R& M/ ^$ `
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
8 T$ f) }( w2 x& S; X( z3 Z7 Xfor i in range(101) :
    if i %2 != 0 :
$ F. t+ d% Y1 x7 H        print(i)

1 ]1 a: h) D) j6 _. ?count=0
- `6 a- b# \) S0 zwhile count<100 :
    if count %2 != 0 :
. }7 [2 [6 C4 Z- @4 L. z8 a        print(count)
. i" y$ b5 ]3 @' g    count += 1
& y% E, E/ _* r- e) |9 g3 j
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* N9 e% b# Z4 K. m! G7 o% Q( F' S    if i %2 == 0:
        print(i)
* x. N1 K- i" Y; Z$ E6 {( [
; r5 a% T* P. X: qcount=0
* X% y- i0 y  C; s" Nwhile count<100 :
0 W; U! U2 r; Y+ a0 N/ f0 q* I    if count%2 == 0 :
/ [' }) w# W  n% O7 h$ i        print(count)
6 D! T0 L4 A) K# K; P7 a0 T    count+=1
! r9 k3 X& n6 X
  l) _9 f) O) J$ t4 }; z8 c12、分别书写数字 5，10，32，7 的二进制表示

' u( H( r% z! Y! Tprint(bin(5))二进制   0b101
5 P7 Y% i1 U$ {* E9 L) b1 y8 W% I+ g" yprint(hex(10))十六进制  0x5
$ {" A+ o; d  T% }- J4 xprint(oct(5))  八进制  0o5
* Y7 S! k7 g  f1 B14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

& Q- T) A$ G8 M1 V* l4 d; l16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
" C9 n$ d) U/ }( s& k( B3 |print(int.bit_length(n1))  结果  3

9 l* `  o' q, S. ~5 d; {! E18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
* }, P* T+ l# E# V4 A3 Gc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
8 m$ F! n! o) `' B# }d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
  P  K  P& G: P( `print(name.replace('l','p'))   apex  
! g, n& t9 D% i8 Fe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
& n' s" j8 T8 Pprint(name.split('e'))   ['al', 'x  ']  列表
4 |! c0 F+ U3 ?% _8 d3 \4 }
' y9 `9 m/ N/ X0 O( ?g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
8 g# n0 h8 Q  N( O6 r6 d
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
4 c: r0 B8 n5 b4 k依赖索引
name = "Alex  "
" R* D9 v# l/ x: e- Mfor i in range(len(name)) :
& N/ T5 [% a% H    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
4 q  q$ J0 ~* W; P4 ]5 T22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
) a4 f8 ]' U5 l7 A) B- x$ o- @print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. h' z# Y; [9 m1 Oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
2 d) F! S: k# a# R4 Z9 K6 dprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 i4 |( w& F2 Y  F* I& d5 kli.pop(1)
- Y$ J7 G; H* P0 U* }# ]6 F( Qprint(li)    ['alex', 'rain']
- q1 z" _- r& P' d5 P指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
6 z3 ]! n- G. W9 Wprint(li)
# L0 i: J1 o- w! \f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 y# e. Y2 h# M! H" Qprint(li.pop(1))
7 o* R! X- b3 V2 r1 \, c" L$ Qprint(li)

eric
+ f+ W8 I: P8 |5 B, [" t) e['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
0 d2 D/ T- u6 D' W$ C: }8 K! fprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
- r7 ~) i2 z/ V4 M: A# r" O8 P3 o3 qli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) w) }- O+ V1 j* f( ea. 请输出 “Kelly”
& i$ y8 k7 I. U4 r& G$ m: k  rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
1 {, }$ d! W/ vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 G: n7 _3 ~& L1 X$ A, pli[2][2]='ALL'
) Q* ^7 s. ?  j( p8 v+ Tprint(li)
5 E4 _6 [" }* K/ s. C24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ G1 k' O  M$ `8 ~- q/ F/ Ha. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 B8 Z: J: ?/ t+ ]print(len(tu))
+ h% Y2 W6 ]* o7 T& C( D/ Ub. 获取元组的第 2 个元素，并输出
print(tu[1])
# L3 Z0 I' _# ne. 请使用 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)
- a, q' J9 F# J. v+ K6 D10 alex
) n0 C. M1 B5 Z7 Z  ~( J7 b11 eric
4 l# K: `* Z$ e; f* Z) q12 rain
# `! m# H7 h! f8 q
$ r+ _4 `  k) G9 m" K1 [$ q# Gfor k in enumerate(tu,10) :
4 l# [2 x3 j. O0 O7 F2 W) `    print(k)
(10, 'alex')
(11, 'eric')
% V& b* S4 s) X" _(12, 'rain')
! H1 w. H7 n: l3 M
+ z- u, g) o$ F% o# V# B! i6 j
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: t5 A" y6 l9 O* j  ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
  O- ^3 h( q0 A/ W  w. ^$ adic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
4 j" Y) r  T$ {" s0 [6 {; b$ b. Yfor i in dic:
0 k( x" w, o. i* i2 q% ^    print(dic)
8 T6 i) V- [7 Lc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
* e% p- R  }0 p3 |d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
' l/ |$ A% F" E8 `7 {print(dic)
0 U5 }. y% h* N; Q* J- E7 C* @0 Pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
3 x( D  ^: D& ]& P* w" R% Jdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 A2 V; r8 M6 w6 M- M( ddic['k3'].append(44)
print(dic)
2 j; a6 ~, X$ _0 b9 _
3 j! Y3 m7 I  a$ ng. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 w) A" D9 p- M1 [( D2 M) Xdic['k3'].insert(0,44)
) r' Z& v  ]" ~) xprint(dic)
$ B9 M* E4 M7 e" e! _- {! o27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
6 f; d9 K* `/ O; R& @  }$ ^
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  q3 @2 }7 C6 C0 k8 R- gs = "alex"
print(tuple(s))
* M- ]6 F- l) z. }- \1 E
0 K8 Q! @& L3 ~8 ?b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
* w/ r: n+ d. G  O- Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 l+ k4 y: O9 g9 |tu = ('Alex', "seven")
1 a+ Q9 f3 W8 U) w; ?! ?6 b$ bli=list(tu)
print(li)
- s( f9 U! m9 O8 I

- `7 l( ^; I7 @3 q# pd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

5 |0 e; u# k9 X& qdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 W* d' _& ?6 w* e* m! o1 I/ y" r- wa=n.encode('utf-8')   
print(a)
8 p3 R2 T- l) ub=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
: K! n' s+ u; x: _0 q( W6 z) c6 pb=a.decode('gbk')
5 C! k7 z- _0 M9 W* U' g4 o5 y) eprint(b)28、求 1-100 内的所有数的和
count=1
0 \$ d7 D; F8 E: e0 usum=0
for i in range(100) :
8 L. f5 _. X% p/ X% s    sum=sum+count
    count+=1
7 n5 L- b  z! t. L, jprint(sum)

' L4 o. t: j, J4 Wcount=1
sum=0
while count<=100 :
7 b7 i) j2 D8 y3 i  ?, A    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: ~9 w$ P/ k) d, K6 Q- y* _# }将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
$ x* H( k' J" R0 `* m    'min':[]
+ Q1 y, g2 ]" ^5 \/ n}
$ E# s7 H5 {0 Z( |! A/ V: Jfor i in li :
    if i <66 :
1 b9 w: l- i1 H        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
" I; ^# v, Z- j) }! C' L! N$ uprint(dic1)

. ?8 K# |+ Z9 P---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! L9 m9 e6 {8 F1 ?$ N, n+ W/ U