Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

5 S4 e$ _1 E# k. {$ m) M3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

' n/ A' Q7 k: f- X6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
; O* m. A- h8 {1 O1 i4 sz=1
- m1 X. Q' C1 x5 y1 K/ {/ d  ^# xprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

) C- l3 S  `9 N10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
6 a% ?; u" A3 G1 I7 Rname=input('name:').strip()
2 t0 L$ r/ n3 Gpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
. }, q! w& Q) @7 A1 Y6 I" e& M: T    print('ok')
else:
% S/ n+ D" l4 v1 [    print('error')
: {0 s3 J5 g. U( {8 o$ e
* W$ q0 |" ~2 ~8 |4 y! zb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
) R8 m1 I0 H6 qcount=1
5 o0 M& J" V$ x( Z+ f- fwhile count<=3 :
' B4 @" y2 C4 r    name = input('name:').strip()
    pwd = input('pwd：').strip()
+ L- I1 [* w6 V8 X
4 |: E- Y  a+ _1 |' v    if name=='seven' and pwd=='123' :
% \7 _: d/ M7 p7 ^5 F3 ~# c) ^        print('ok')
& i; X5 K# Y. W4 m    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

( s+ \/ T$ c# i/ [  g3 r  v    if name=='seven' and pwd=='123' :
  y7 k/ Z4 ]. }% w        print('ok')
3 l/ v. Q4 ]8 p$ q3 C: R    else:
6 Q0 M' ^% x, M5 V( c/ L        print('error')
) q  v, Z4 R* X, q' _        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
: s2 L( U) [. `4 Dwhile count<=3 :
, ^1 U2 b  a& O* c8 b* }3 f    name = input('name: ')
" e5 t4 Q4 d- a' s7 y6 R7 f" \    pwd = input('pwd: ')
/ S* Z7 f6 [( B    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 H0 y% `& x2 E3 {! W1 t        print('ok')
0 L$ X; O3 T4 W. |4 c    else :
- o" l9 c4 j; E' W/ R        print('error')
7 x4 `+ q) F1 o        count+=1
! s& R5 {  j% O4 z1 h& Xfor循环
for count in range(3)  :
    name = input('name: ')
' n' B! ^7 g/ z    pwd = input('pwd: ')
" _% G) b; {/ D- I    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: x2 ~0 m# [! {# H        print('ok')
% |  f7 ^( P/ j    else :
        print('error')
: X, S" C/ h. I, C# E; m7 ~8 s& L) E; [        count+=111、写代码
3 e. L' ?1 r3 Qa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
8 H/ b* ~2 V& t- f* V    if count % 2 ==0 :
        num=count+num
9 I6 h& x6 E* g# d4 ?" p9 h        count+=1
; S" `$ [- U4 @. t0 G/ Q6 X    else:
        num=num-count
" y5 b7 a, u  i0 [; P; n3 I2 C" X        count+=1
print(num)
& r) }9 y& }" q% e, e9 ]
, E* L1 H" y0 C; e  v# K3 b) Tb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
; l/ \8 v# q' X3 W num=0
* U; B. ?# E9 x! J# O2 fcount=1
5 H" \# h& e& ^2 t) |for count in range(100) :
    if count % 2 == 0 :
; e0 _9 b8 n5 z% u& t3 }- p        num=num - count
    else :
* }' Y( ?( t- B' |0 [8 Z        num=num+count
0 J/ }; p% I' ?! Q) A6 `. R1 Wprint(num)

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

count=1
while count < 13 :
! P7 o$ |- L) M" s$ ?    if count !=6 :
$ B" V& |" a9 a4 u2 `        if count !=10 :
. k8 y* b, N' c0 e) T+ C            print(count)

* l' C3 U" _: K" O' l- b& n8 _    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
% U% O- _4 r) i1 `for i in range(101) :
5 i( f; q: \( V2 d# U6 t    if i %2 != 0 :
        print(i)
# T. j3 H' Z/ [
count=0
. ~/ ?# ^6 z# L" L' ywhile count<100 :
4 S) c. x1 j/ o- c/ c4 s; T% i    if count %2 != 0 :
        print(count)
    count += 1

1 @9 v9 m9 H+ |4 G: N$ ^3 C; _e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
1 J  H- k5 E2 Z- s9 `. }: o        print(i)

count=0
while count<100 :
3 U# T0 o' Q4 i6 r0 j# g    if count%2 == 0 :
" @; N" f1 d2 P2 C' P        print(count)
# z# q% l- V" r8 u/ ^! q2 Y    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
' n3 T9 C! J: K2 u
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
) K* Y, @& t0 u% wprint(oct(5))  八进制  0o5
# {4 v8 p( ^* u* Q- g14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
9 S) ~( M! u) @/ D; w" Q; m3 vprint(int.bit_length(n1))  结果  3

5 q3 D. J3 ^/ }18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
# H5 P; [! y1 a4 K. yd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
/ @' @9 t0 m; R2 i1 j. ^
$ Y- Z  `+ T  H9 {2 E$ Z7 |g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
( T- Y2 j  b6 F: ofor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
! v/ ^$ \6 C* [* ^( F22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 v9 T2 O- M" n3 D' T% K1 Yprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
" b. N6 t  N$ y- Vprint(li)
['alex', 'eric', 'rain', 'seven']
$ i' B9 F: C4 @! Sc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
: r+ P5 y$ ?: Lprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" @7 v) s, n( c; {/ i0 _; W3 N. tli.pop(1)
print(li)    ['alex', 'rain']
* |0 W7 j" i, s/ g6 i+ Z. F指名道姓的删除li = ['alex', 'eric', 'rain']
; ~1 T' Q% p. X6 V- ?: s. t1 U) _li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
) Q9 A% w3 m5 u& e) F8 D
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
+ Z3 V! O9 {* d/ q/ z; _, Q0 S+ mdel li[1:]
7 j0 @/ m, I: d, K  s) _2 `print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
- ]. a$ Q0 w& K! |; p+ ]& ]li = ['alex', 'eric', 'rain']
: n( ~: e( Y' U. pfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
5 }& t) |( P) cli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
) j7 F  ]4 O# D* \, Pli[2][2]='ALL'
+ X' E$ d9 r9 g3 Rprint(li)
" z, M2 _# S) Z$ A  [2 A/ j' Z& G) n0 e24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
7 x" |2 g6 w: b9 f) W2 C1 Q  L% J' Vb. 获取元组的第 2 个元素，并输出
7 s  u. K9 }" K" Q! p4 ~+ M/ Aprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
$ Z* Y; A  v, B0 K( m, Xfor i in range(len(tu)) :
# c1 J; N9 t6 V. A$ n; r    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
7 Z7 c7 X; l% l: Y    print(k,v)
10 alex
11 eric
12 rain
& Z% O! S) m! ?0 @+ Z1 o0 }
* e# J# K2 n0 }. R% Bfor k in enumerate(tu,10) :
    print(k)
2 t+ \0 ~, x" F9 h& g, p) e(10, 'alex')
4 g! |: ]" q  ?$ |. J& t$ w- w  A+ I(11, 'eric')
: K; B; R# b1 J" q2 T+ B: H  }(12, 'rain')
- |: H' t- y5 c  d

: G* j9 S5 Z/ n6 U& |$ V) A: }25、有如下变量，请实现要求的功能
: j3 n$ M6 F2 j  d- ^) htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

  M9 o+ o7 U( F$ l; H, Bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. j  B/ C2 o4 Q5 etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
: @6 ?% w- L" U- [# ]0 hres=tu[1][2]['k2'].append('seven')
* ]+ l' ?$ G/ M; p! ^
- {: k' x4 b7 Q( Vprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
: A3 I- i7 F- `    print(i)b. 请循环输出所有的 value
+ F% A$ a. r- t0 {8 h7 m' n' a2 zfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
2 C( L1 c; Q  A8 p( s, h' [5 Y3 q: pprint(i,dic)
* `8 p) s! s7 S; A5 Q7 R/ n% f+ ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
# Z+ Z; K3 W  Q* Q+ L1 Kdic['k4']='v4'
print(dic)
" L. m/ }7 a( S/ `% be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
8 o% ~+ i( F+ w, x# l
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, T2 g2 c8 n- E2 [dic['k3'].insert(0,44)
- z( I# A. J8 H6 A2 @" eprint(dic)
  \$ I  G6 v, D. v( E27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
. g; M7 o5 f! V/ P2 i) Gs = "alex"
print(tuple(s))
4 G! z* |3 L2 _4 j7 S
b. 将列表 li = ["alex", "seven"] 转换成元组
& v1 V; t7 i7 P- o# sli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
; L. Q* q* X6 a+ V) Hli=list(tu)
* B3 Y- s& e2 i( D, @print(li)
0 E# x% X# |! h) G

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

: S# N% I1 R$ r, @dic={}
2 Z& k- ]& O8 Ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# m  ~0 i+ o' w( Y% Y    dic[k]=v
$ u$ r6 i) \3 g7 u    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 k2 \* V! v/ m$ ]1 i8 Da=n.encode('utf-8')   
* a3 N% r7 [7 i' O; k7 ~5 D7 Yprint(a)
b=a.decode('utf-8')
print(b)
8 r$ X4 s+ x9 Z! q' Eb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
$ @3 m/ h. ]. j4 c) vprint(b)28、求 1-100 内的所有数的和
count=1
) E- r1 \7 l6 W+ H' M5 [( |$ {sum=0
2 B+ F  c- k2 ifor i in range(100) :
1 b5 `: ^) P+ Y6 ^' }    sum=sum+count
1 M  I  ]" |/ d* @" ?& q    count+=1
print(sum)

count=1
sum=0
- d8 B, g+ w" O  Q+ Iwhile count<=100 :
    sum+=count
' N8 o! k, k& O; O2 }    count+=1
2 X) V+ }/ a+ _, F: e- Z. fprint(sum)29、元素分类
. o, y2 e! {* G; v4 F有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
; B6 Z" O# U& c1 c) B7 A- N将小于 66 的值保存至第二个 key 的值中。
/ B* M) {$ _! W3 f即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
* T9 Y5 u( P7 t! ^1 B7 c# O    'max':[],
; g3 E  j! M7 y# X    'min':[]
}
& D" k3 ~' F# |7 w8 K& wfor i in li :
" r5 [) y+ j# f! B    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
# z, J: C3 I1 M1 ^' g' A4 Nprint(dic1)

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