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 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
1 V! O/ d7 }* ^( Mz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

# g! U* l0 y# e3 `+ ~2 ^5 p10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
9 I. e  I  Y. Nname=input('name:').strip()
pwd=input('pwd：').strip()
. }& [2 h8 S8 t& @2 [. qif name=='seven' and pwd=='123' :
' [6 a( ^* t/ ]& i; W* T    print('ok')
* s! [' n6 G( B, _8 kelse:
/ Q8 s+ Q; g% D. Y) G$ g+ Y0 Y    print('error')

- J8 S2 D8 F) G1 F. j- R" ab.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
( E3 h. t3 |" ~) E8 G. acount=1
while count<=3 :
! r6 i) u/ @8 p  l9 ~0 B    name = input('name:').strip()
    pwd = input('pwd：').strip()
! }/ J. p# u& |" s
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
2 b, _8 o) b/ W% o+ E        print('error')
3 ]( ^: A( [% W0 y! y, Y        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
$ d1 _1 z4 L# l: ?7 u% l4 Q8 B+ d4 \" e    pwd = input('pwd：').strip()

& H" D  A  s( y5 c5 k4 `    if name=='seven' and pwd=='123' :
        print('ok')
# p, R/ ^! m  D" f, f  s% v    else:
& I; h# k& U  F1 U$ D7 O: M, @( p        print('error')
2 L% s& s0 t2 _/ L) T+ Q3 `        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
" x8 F$ X" ~2 U* `count =1
! @1 v3 S2 z! ^$ D+ pwhile count<=3 :
    name = input('name: ')
; P, k: c2 _( S! M8 V/ F    pwd = input('pwd: ')
% k/ |+ q, D* _* Q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& h8 u$ x- C) y        print('ok')
2 u: H- L2 E" k0 M  e# c' |8 n* ?    else :
; E! ]$ A. C6 w* r3 d5 l        print('error')
        count+=1
for循环
3 r! U8 H  s9 u2 ~for count in range(3)  :
    name = input('name: ')
, l( G1 p# I0 S% n9 M$ }    pwd = input('pwd: ')
" c( c& [( b. G9 p% u: Q# L    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
! Q7 }: b5 Z) |( L    else :
        print('error')
8 }7 S; k$ t( }! ?1 j        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
. p3 K+ D1 A3 M) P; ecount=2
: e# Q; O& L- b  ?+ A6 X5 b8 U# X, onum=0
while count<=100 :
    if count % 2 ==0 :
: ~  ?! z7 }% T, {% u$ v5 k4 k* _        num=count+num
5 a; l& `" p: M) G7 V, R* L5 Z        count+=1
    else:
  p* I& v0 D  G8 I8 H. z        num=num-count
        count+=1
: O; w' f, D9 C/ o" O4 n) Iprint(num)
' w. Y* ?+ X# Y* h  n+ z+ l" r. j
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
5 P- S- E, K' i$ a num=0
count=1
for count in range(100) :
$ L' O/ _# @' {" I% @9 D    if count % 2 == 0 :
        num=num - count
7 [: I4 Q2 x. G! T- I2 ]    else :
5 Y6 I8 U2 x2 T        num=num+count
+ U3 S6 r2 k7 i& {; }5 ^3 M& d, Qprint(num)

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

count=1
while count < 13 :
    if count !=6 :
3 _5 I5 [# D8 y" k% @- S! L8 N; {        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
( L2 R4 R( v2 X+ Vfor i in range(101) :
1 t1 V, q- e/ q; f8 P/ ^    if i %2 != 0 :
        print(i)
; S- ~1 L4 t3 x7 E2 x! m
count=0
while count<100 :
; r  X! X# A9 w0 \    if count %2 != 0 :
3 o4 b) A- v& I) b/ K        print(count)
6 s# [4 t9 m! E( Z3 V6 C* O* e3 h    count += 1
4 ~/ P# f1 x4 j6 O
% g! j1 n2 \2 i( _8 l* ee. 使用 while 循环实现输出 1-100 内的所有偶数
7 R9 J2 C+ W2 ?0 Y2 C* ufor i in range(100) :
    if i %2 == 0:
        print(i)
/ S* G( \3 H3 q7 F6 ~! T* u+ h8 t
- m2 q7 v6 F- b7 Fcount=0
4 O+ r+ s8 V- \) }while count<100 :
    if count%2 == 0 :
        print(count)
4 j+ {- E- m2 p3 I: V- l    count+=1

; `. M5 q: j) J* O4 ~% ~12、分别书写数字 5，10，32，7 的二进制表示
' O+ R+ p& X. |9 Q9 j' I: L, Z) }8 B* Z
print(bin(5))二进制   0b101
9 q; y  _5 `& x  Q' y5 o: gprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

18、布尔值分别有什么?

False .Ture ,或1  和0

. g# x, [7 Z* P1 Q20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
& M' `1 L& o- S, wa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

# s# N' x' \! y/ L+ sb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
$ d9 h  b5 ^$ E6 e4 Y  eprint(name.startswith('al'))
! K5 a" b' V+ f* ^5 ~' R2 kc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
' Q8 g' R1 A4 Q, Kd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
0 I4 f- v+ l" K6 N( c, d! Oe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
5 B/ B8 P3 {- w9 _
# ]  Y9 f5 ~. B- D% f! Jg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
- h1 N( Y2 Y3 t
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
- D+ \; ]' g, x( m: J4 g1 mname = "Alex  "
  o2 b7 \' h, n, V: c6 f5 g/ yfor 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
6 }5 o, ^! T; N22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
$ c+ U- [2 t* {/ d: ~; p/ D( qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
- J* q0 s2 r; Wc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 x, k+ `, A* J. t- @, Mprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
2 N9 ?0 p. P2 H8 U指名道姓的删除li = ['alex', 'eric', 'rain']
7 q: \$ S4 t1 L6 ?& Oli.remove('alex')
- O4 V3 F! C8 |print(li)
/ Q7 _$ U# E- _7 ?/ J/ z7 d* Ef. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
3 t* E% X' \: X3 x: eprint(li.pop(1))
print(li)

eric
* Z. A4 C! i+ Q& a# f( W['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
( `0 Z3 _" P. X* i8 S: c! Pdel li[1:]
; q) E) o) a# h( P0 P. ?2 rprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
7 M; |% b# {! _( \( A( i& f3 s    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, K& f+ y2 k/ g4 W7 f& ka. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% S& _" ]0 k) ?8 ], \( |5 ?print(li[2][1][1])
+ m" F6 j% J$ F' jb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 I. ?  D7 o4 a& Ili[2][2]='ALL'
2 b0 ~0 K* B& }: c4 t- C+ Y# Y8 e4 [/ xprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
! i- f) a+ L( S- O4 @/ x1 K; Jb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
& f5 s& r" W! n& Kfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, w% g; K; L4 X& P* @for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
" C& A0 @4 f5 i+ m9 s4 o+ }12 rain
" @0 g! w" j' h4 F) g9 m
for k in enumerate(tu,10) :
, f2 H  s. G, a+ {5 ?    print(k)
( Y' i' U2 m# q2 Z(10, 'alex')
0 w3 Z) U; }5 }( r% B  {) j/ U: ^(11, 'eric')
(12, 'rain')
! F; `& T4 n. K- @
2 Y2 L/ Y6 N& p
25、有如下变量，请实现要求的功能
4 o7 u8 Q4 x- _7 O  c- p% L5 }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
2 J/ `2 V! B; |. X& g! r" Z0 Y+ s
print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  {; h7 x$ Q. W4 g4 u; U    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
$ C8 S: M0 o' N% c0 n# M% W* Zc. 请循环输出所有的 key 和 valuefor i in dic:
" ]( f9 `! o( S: R+ Fprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
% O) ~8 b: `$ oprint(dic)
( q' P( G4 A( b+ d* v3 K  Ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
4 J- V8 T. m6 d6 Yprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
7 ~! o/ W/ X  _7 \" W& n
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
( H. y! ]  c9 k: iprint(dic)
; Q; Z. I8 m  `2 I# x: S27、转换
" c7 _0 W& {( A7 A' Ma. 将字符串 s = "alex" 转换成列表  s = "alex"
9 D" \) J: G3 A' N. h
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
5 k3 Z$ I) o# q3 r( E. C: n1 w$ j# G0 gprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
& W: K1 P7 [( p# o1 lli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
4 E: }, T0 M# W. X8 E; stu = ('Alex', "seven")
3 }% b( i# q" a  yli=list(tu)
print(li)
7 ]4 A' P+ V+ ]" [* f: q0 T

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 }- A- y- V0 J- E! x7 y! n
dic={}
! G" S9 x) W7 |5 N9 Z+ {for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
8 u& k, `6 |6 f& f7 za. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
& d5 q. J! E* s* y" da=n.encode('utf-8')   
print(a)
  V. s3 A) p: U+ _& pb=a.decode('utf-8')
- H, ?% i  l7 P& D1 j! \% M" m' Kprint(b)
; j2 n2 h$ G4 D8 Q/ q$ @b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
5 z; K. O: i; J! Y+ v, pprint(a)
- X! i* x: Y" _+ wb=a.decode('gbk')
- o! q% D8 q4 i0 n; q( C& jprint(b)28、求 1-100 内的所有数的和
2 E7 g, q, t$ S" B" H# X" jcount=1
: Y! F5 m. c& z' ^  E$ i9 \- D/ i# Tsum=0
for i in range(100) :
$ R9 D4 Z% `; O; n0 \5 q. |" c    sum=sum+count
    count+=1
print(sum)

count=1
sum=0
4 f) A+ l% h5 n/ g! lwhile count<=100 :
' |" z7 m- m+ [2 s: l6 q" Z    sum+=count
    count+=1
9 M% o  M0 \5 W. [4 z7 t- G7 xprint(sum)29、元素分类
9 g+ Z- U' I' ]. x/ C有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, j9 e2 |4 `2 ?; d* k将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 ]" o" i0 V* `6 Y% ]0 Lli=[11,22,33,44,55,66,77,88,99,90]
2 n' y+ M6 p2 f5 A# j- R- {dic1={
+ g3 c3 f% _0 z5 V# @  L    'max':[],
+ |6 V: {) X+ C) V5 a. e    'min':[]
}
' c; t& l; Y+ C: s2 C' Z, vfor i in li :
    if i <66 :
        dic1['min'].append(i)
" w$ y2 \" T* b# [& l) s5 G! f' B: B    else:
        dic1['max'].append(i)
print(dic1)
1 F0 O0 s# e6 j. u
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}