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、如何查看变量在内存中的地址?
z=1
0 W9 u! P# j$ `; R6 o* Z. B$ V1 N9 iprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
$ y2 Y+ N1 B. v, l3 w0 Ya.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
5 K) b! i1 O9 u  Gpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
4 }  Q, ~* E8 s: d. `& Oelse:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
( I9 b* t  N2 p; [1 ucount=1
while count<=3 :
; O  v3 ?5 v5 a% f" S' E$ v  ~0 D; p    name = input('name:').strip()
$ s/ f* @' Q. ?. _5 I$ o, D' o5 R    pwd = input('pwd：').strip()
& U* h6 i- O7 C% U& N
2 o/ l" ~7 g: o6 o    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
/ A8 \8 h# e' y! Ifor循环：
  L0 w, `5 z8 b- Pfor count in range(3) :
    name = input('name:').strip()
, ?; b+ y# ~( z9 D( \    pwd = input('pwd：').strip()
, i. \' o$ y4 [' m3 z( `! Q
0 h9 j4 L' q4 ^1 t# B    if name=='seven' and pwd=='123' :
        print('ok')
    else:
+ R; P* M& L+ e6 a! U        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
! `1 y0 C5 i" B1 ]/ b9 p% _count =1
9 D% h- x1 A. D! Zwhile count<=3 :
    name = input('name: ')
& T3 X( h8 d* m5 ?) X, e    pwd = input('pwd: ')
6 W6 O2 H6 r% v! Q1 d* s    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
/ A5 i! z! h- Z; N1 D+ e        print('ok')
0 p3 }7 }$ T: R: M( r    else :
        print('error')
0 n( G5 e2 T# F2 k        count+=1
for循环
; m" t' A- D/ v7 i$ Xfor count in range(3)  :
, C1 B7 v& @4 f: u    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
7 p2 t% V& C/ F( q( Y+ I3 S        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
: d. a; c& B& O! e- j: Dnum=0
while count<=100 :
7 x7 v: }+ _8 q6 f# A9 f8 v    if count % 2 ==0 :
" y, b$ n2 W' I2 B& O4 z2 h5 F        num=count+num
        count+=1
) d) `( \& r2 k6 V# ?5 A/ o    else:
        num=num-count
3 N3 r0 h* g7 `  {        count+=1
4 C/ @: z  R* r( S3 s0 I  t; Tprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
1 C! O# }! u/ Q# _* I, e, Pcount=1
) [. |4 w( V: V1 Bfor count in range(100) :
. b% {4 E% g* n    if count % 2 == 0 :
        num=num - count
8 y/ V7 g9 q" c* C8 w" z    else :
        num=num+count
9 {/ B7 I4 r- R, ^4 ]9 K: Iprint(num)

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

' D1 p7 h& N% p/ A2 mcount=1
1 s/ L" _; c# H$ iwhile count < 13 :
6 i- A! T4 ]/ p  g- {    if count !=6 :
  t# p' R- T3 w& z        if count !=10 :
. }% u7 a  i, [- N            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
- g' b: v$ p5 l9 m7 w" rfor i in range(101) :
/ L% I2 D% Q0 ^1 a' I( u    if i %2 != 0 :
        print(i)
( ]. o2 j' {) o9 n
count=0
while count<100 :
& n/ \1 R# i' ?+ ^( n' N    if count %2 != 0 :
6 ~! ^% u5 a' x, r2 ~4 r! k- B        print(count)
* @; z7 z$ z' N5 q6 Q3 g! i0 [    count += 1

8 p: O9 `- t% d4 Q6 l! Le. 使用 while 循环实现输出 1-100 内的所有偶数
4 r& v6 }3 J! q8 _. |for i in range(100) :
0 C  {; m' j1 G. \+ k    if i %2 == 0:
" Z3 w- a/ `1 w: A1 m, M# H2 b        print(i)
; c1 E4 {5 K+ j8 T8 W
count=0
& \! Q6 G! D9 t6 q( X# p5 wwhile count<100 :
5 ?. z3 R: _/ M& O% p+ E1 H+ n# W    if count%2 == 0 :
        print(count)
    count+=1

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

$ J- b- |) Q! w4 w- P1 C! U1 b8 |0 d0 Jprint(bin(5))二进制   0b101
1 i1 v* F$ F- c) `5 K! g$ fprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
; G; z. ]- [9 q/ O14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

- d1 N& e1 {. q$ E16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
$ T: c( n, W( N: C, v3 @( d17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
& w, l4 G' W4 m  o2 n/ wa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

% r; p. N7 d$ E  \  t) i! [b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
/ k! e, \" Q) \. V4 ?print(name.startswith('al'))
( I, I* Y  Y& ]% c6 Cc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
: Q8 y, g, U& \2 e2 ^0 p8 Bprint(name.replace('l','p'))   apex  
$ }* @9 Q+ j+ \e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
) l9 @9 v& ^" M4 N. ~5 Z( bprint(name.split('e'))   ['al', 'x  ']  列表

4 f5 }" Y3 Q* i, d; r- Rg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

( S" L  |2 e  m, `0 `% pj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
5 Z( n5 S3 v4 S21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
8 ~. A3 q8 r4 |8 [# dname = "Alex  "
for i in range(len(name)) :
; N  {& F! ], u, C1 @; n+ D7 H    print(name)
! ^0 Z3 h+ V8 Z3 Bfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
0 m" a8 ^0 K: Y, q) k- Z# }22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
6 ~# k* s9 N  S6 j+ R1 ?# bprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
4 g' ?7 E. P' j4 z) n: r1 Mprint(li)
['alex', 'eric', 'rain', 'seven']
' q/ ~( @6 [4 I1 y4 Tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 t7 V/ ~5 P$ X6 hprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; `) ^; @/ Q' V( r6 I/ Ali.pop(1)
print(li)    ['alex', 'rain']
2 v; D3 a. `- F* u5 V: f! C指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
" l4 V2 {9 H; \% P4 |print(li.pop(1))
print(li)

5 B* E! e/ |: m8 Weric
6 h5 c5 o# y- B& u; Z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ Z6 a: X2 i5 u. {del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
. U2 }. m1 D3 v) \6 lfor k,v in enumerate(li,1):
% @. V+ S2 u3 J0 m    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: p- A& V  K( d% T4 ^9 w1 }a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
' e5 q7 N& H# I& n( fli[2][2]='ALL'
print(li)
- y  N. e3 Q% L3 H24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* G9 N0 P3 h+ \0 ba. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" J& a: C$ T- sprint(len(tu))
  F; U5 l  O: T  A6 lb. 获取元组的第 2 个元素，并输出
print(tu[1])
; a" K( t2 R( }% @6 ]& Xe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% l. H- a. z# `* E# o7 ?5 tfor k,v in enumerate(tu,10) :
1 U- L. P$ g) |$ `. K    print(k,v)
10 alex
11 eric
12 rain
6 E1 ]7 k/ v+ I
for k in enumerate(tu,10) :
    print(k)
" ]3 N% X* ]8 u(10, 'alex')
  `, K1 }, t+ S(11, 'eric')
(12, 'rain')


25、有如下变量，请实现要求的功能
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])
2 B4 i5 G5 P( ^; {9 y( h9 Zres=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
, J- c5 `5 |$ M3 b* ]/ Ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
+ R* O5 Z1 v/ I0 B: a( T: X    print(i)b. 请循环输出所有的 value
* M& c1 P& G6 _: B! t$ x7 h) Afor i in dic:
! O7 ?$ `3 F7 R    print(dic)
  u$ d( H% Z9 n4 }; hc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
) h$ _0 c8 l4 Wprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
; t. F4 `5 J9 m* F$ N' X( wdic['k1']='alex'
$ w/ R4 w7 b$ e* Xprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& I# @, b* ^- xdic['k3'].append(44)
print(dic)

! u8 j" `3 l  N3 `3 k9 F" xg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
: {9 Z& ?& c' ?4 qa. 将字符串 s = "alex" 转换成列表  s = "alex"
* C' Q5 F3 l' o+ n
; k% A4 Y6 ?$ aprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
( |5 J1 u' ^& U* Q  o/ b' ~2 Q" xprint(tuple(s))
* s1 q3 w6 Q; G% }. F2 Z
5 Q" z# t$ A4 f2 O1 m1 Y2 E) hb. 将列表 li = ["alex", "seven"] 转换成元组
# d* _! {) m( F4 D; J6 ~+ [: s$ R# Lli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
: I* v6 [; w& {# F9 Ytu = ('Alex', "seven")
, H# B# w8 D5 z9 b' l$ b8 K- Pli=list(tu)
print(li)

& Z8 Q# Y- o0 f+ \3 v( M3 h
$ w; q+ N/ w' V8 k! Dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
  M" [3 U% V8 Y9 W- ]- j/ O
dic={}
% P- j0 U: g2 R  {% E; o1 X- ]for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
) e8 `7 v. ?" z! B" J$ {    print(dic)27、转码n = "老男孩"
2 j# M0 t. j4 `' g7 m( T! R1 Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! F$ ~) X# r" g3 Da=n.encode('utf-8')   
print(a)
' P6 }1 k% F( M3 L' vb=a.decode('utf-8')
/ u, f- h" |5 \print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
, j$ `; V, f" ?8 b& _2 pcount=1
sum=0
7 Y) L  J0 q6 ^; L! P2 `for i in range(100) :
    sum=sum+count
! A$ \' z8 s, d0 S    count+=1
0 s" k7 R" c* W6 b* P( |print(sum)

count=1
( ]/ f* J9 ?" Q8 g. l4 @sum=0
& j$ q  ?6 l3 G% ~3 nwhile count<=100 :
    sum+=count
1 t" R; K( o- \    count+=1
5 ?% B/ m0 |% w8 G5 k; P! ]print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
* Q9 e; j2 w% Z: d! Q将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
) o' c+ Z9 @) w( V& k3 Cdic1={
$ I9 ]* I& J9 J    'max':[],
: E1 B, V0 V: x, o, K# [  v    'min':[]
}
for i in li :
7 ?0 Z7 a2 W9 Q& x    if i <66 :
        dic1['min'].append(i)
" _# ~; r* m/ J9 N" m1 I7 F    else:
        dic1['max'].append(i)
print(dic1)
, z( b! w0 n2 M7 C1 m
( [8 z1 i2 H6 A---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
& ?( f* U8 c3 J! j0 U0 r/ r. v