Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

4 j) G5 p0 B5 ], G3、简述 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

0 p3 z- f& A1 f- K5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

; H& D- t: d, _+ m& F8、如何查看变量在内存中的地址?
z=1
; |+ D8 P2 i! B& _7 e" B9 lprint(id(z))
' {" c" O/ ?& L5 P% q" P9 r) @" Q/ ~  v/ z9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

$ S9 W( n: q+ ~' y0 D! c10、写代码
1 u6 t# }' G8 za.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
) c4 v- V& h4 t* Qname=input('name:').strip()
pwd=input('pwd：').strip()
4 h3 h; `4 U3 `% d0 o9 u% |if name=='seven' and pwd=='123' :
+ V3 k% P2 t& _! K    print('ok')
$ D* X3 k: m! ], E& f. Nelse:
7 d, g) B3 |/ y# F0 f9 p; f, F5 Y$ L    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
9 U6 ]* f' }5 d) y9 g- C6 Tcount=1
; o5 Y! ?* @" D6 t! Xwhile count<=3 :
9 t% }4 T2 [8 z* N  F" a' i    name = input('name:').strip()
7 Z$ p/ y; {  M: ^8 M    pwd = input('pwd：').strip()
$ T& X8 i  h5 x. u+ p$ e2 q
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
: R1 r; B" E+ A( z( G3 A; E        print('error')
) @" x3 _( @; O: r, O0 F        count += 1
+ p4 f6 ?5 s! k" T) B- x- ffor循环：
2 k3 x/ J$ O" c; F' v* Cfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
1 x. q2 A; @7 e0 i        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
. u4 U3 ^1 |! _1 c( x2 f7 q3 O, z) w- Wcount =1
3 H8 N# R0 b4 I- a3 L8 y9 cwhile count<=3 :
/ z9 D" H. Y- N    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
7 O1 P) C3 f3 x8 M0 T3 a9 e( ~    else :
        print('error')
        count+=1
for循环
# Y! ]. S2 k1 f3 C% V1 O- S; Ofor count in range(3)  :
" Z: T+ I! @2 E; L9 W    name = input('name: ')
    pwd = input('pwd: ')
7 P1 h% {( ^" U/ r) X4 z' _% n    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ S5 z& v9 G- T5 ?        print('ok')
$ h6 J  o7 j3 `2 x! T; Z    else :
- R4 x* V& P) y9 z* i) U* ]- G        print('error')
" D3 d! H1 m2 L5 W& P9 X        count+=111、写代码
7 {- B' ?! ?$ }' l/ b% r; }5 f7 ua. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
* h7 ]# ^% s- \num=0
7 C' J9 k2 E8 fwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
9 @# g  e# e" K/ N% m( t- y: v        num=num-count
' Z. H. D0 j) x8 t        count+=1
1 c9 a! p( e7 J9 Hprint(num)
. R2 U* _& f1 b  f* ?/ C) ]
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
" q; K7 [6 n* Q num=0
* @. {  [9 i" J5 H: [( A% kcount=1
for count in range(100) :
    if count % 2 == 0 :
. [- v( u" ~. Y* ]0 }        num=num - count
7 h6 k! S( ~4 T. U, B    else :
1 S1 ^. r# I& V0 [* C2 ?( D        num=num+count
5 Q; \! `9 j$ u5 D. W! wprint(num)

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

. i) o! z# C$ I3 h5 `1 g/ }/ Bcount=1
while count < 13 :
* E% l# p: ]8 o- r, Q    if count !=6 :
        if count !=10 :
: [4 \: H! G( s2 i! W            print(count)
8 J, U* Q# C/ H$ J" R( h
! N8 C, E5 c$ f6 h" F3 G4 t+ \    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
) {9 v$ e  H. P- Gfor i in range(101) :
    if i %2 != 0 :
1 U1 [  h+ v0 z! i# a1 r, |. b        print(i)
8 q. Z$ R: N5 I0 n0 S
3 l6 N( ]( y: Z, d) [/ e* ]count=0
while count<100 :
    if count %2 != 0 :
0 j- P4 b' j$ T; F        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
1 B6 a; j  H, J6 U) Q8 S2 @for i in range(100) :
    if i %2 == 0:
$ \8 H3 E4 p" i- U5 p8 P7 ^        print(i)

) f) ?! ?% X5 ^1 y6 e9 u  K$ scount=0
while count<100 :
5 d! Y0 O9 b# @* C! b) l; T4 g    if count%2 == 0 :
( X$ ^) K. w. t" ^1 l        print(count)
; g1 y# Q6 a+ N. A    count+=1
" b; }, p1 [% l. q* F1 i* e) Y6 Q
12、分别书写数字 5，10，32，7 的二进制表示

/ J) l3 }5 k2 H/ vprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
) D5 i2 m# [8 j* @) K14、现有如下两个变量，请简述 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

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

) P/ J3 s/ g4 d4 ]1 v8 lb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
5 `! ~0 ?" Z- ?+ u6 j5 |, xprint(name.startswith('al'))
  P; ^1 B" D1 q" _3 ac. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
8 L2 G1 C8 t7 oprint(name.replace('l','p'))   apex  
) y  `$ e" E6 N4 s: S# Fe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
" a0 ]5 A9 b' x0 S7 i0 hprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
$ b* @% Z4 d8 D  [7 E
" @& A; [4 a% q* q" hj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
' _$ \8 R# f( \; l依赖索引
3 S% m# ]) A3 h  ~% j1 ]# Nname = "Alex  "
* p4 I' P$ n- w* z: B. ifor 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
& J6 d9 J! J$ |  o) P7 h22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
5 ~3 }3 ^1 A8 m' iprint(li)
2 n* y2 h. }8 D' V1 Z ['alex', 'eric', 'rain', 'seven']
2 I$ D. A( @' Z$ zc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
0 f: S, r( {5 oe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
& p8 I9 W. ?/ q% ]/ _3 Gprint(li)    ['alex', 'rain']
+ h1 O1 p1 N9 z指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
; c( Q- I0 o4 P: J+ Vprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
, G" l" B- l4 u: k# d3 |/ Gprint(li.pop(1))
+ M6 ]# A4 k" n3 N* @: a% N  Bprint(li)

* d1 v: _" z: J2 C. Y$ [eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 z( a* Y" Y1 K: |' ?% R( j# }/ `print(li[2][1][1])
% ?& G; J2 I2 |8 c- I( y3 Ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: t. [, r: h( s- y( `: \" y! t: q- }li[2][2]='ALL'
; P, [: v. ~2 E5 e$ Cprint(li)
. U! @$ a2 G- W- w* A5 y% ?. W24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; ?1 P4 A3 G4 @0 I5 y& e+ `a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ ]& G7 ~* ]4 _" dprint(len(tu))
0 z! K+ b2 |9 ^# ^: pb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
# ^7 Z/ e  r6 Q: |% C5 a    print(k,v)
3 ^5 \! \) }6 K+ F& V1 g10 alex
9 m$ W) e- w4 A4 G1 C& q- _: c11 eric
12 rain
. C: M; I; y! [% O; q
$ p  v9 r; y. k4 V: Gfor k in enumerate(tu,10) :
3 u" z; M/ \% t, M! @( t* t    print(k)
(10, 'alex')
% h: a9 t) }: }% r9 O) R(11, 'eric')
. p" S: Q$ _+ ](12, 'rain')
: O. Y7 T* ?3 [5 u
5 E2 f, F7 B* s9 l
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

* t, v( C. H$ K6 ~; \' Dd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 c0 t; C2 l& U# A2 M) j! ^2 M  nres=tu[1][2]['k2'].append('seven')
& E& m' ?5 U( }# J4 T, P! T- C1 X. x
5 |' \$ J: E9 S0 j& iprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* h; W- [% L, J) W    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
2 t/ z: @: Q( v% ]6 {c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
9 F3 E5 |9 G0 e$ X4 `6 x6 M: Nd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  {: O6 I/ X: }" b, G8 ldic['k4']='v4'
9 J9 V  R5 }/ nprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
, b/ |0 Y; g* I6 _# Sdic['k1']='alex'
$ J1 Z2 y& L: c9 E: h+ y- ~8 H, Eprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: X7 F' _. E$ Pdic['k3'].append(44)
print(dic)
  X- U, O2 C. `
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' b5 n# r" }/ C9 Adic['k3'].insert(0,44)
print(dic)
: B9 P$ g/ Q3 n, f! B1 ]27、转换
* i) q. i$ u# b: Ha. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
' {! a) g6 f6 |; N& y" `print(tuple(s))
3 c/ H8 @# |$ U- q
  D) U3 P9 {! Ob. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
, p& V& j5 o( ~; c, K1 e, l, [5 Aprint(li)
1 ?6 ?* T( L0 V' X; {( |$ N9 K

1 S5 R/ H& {  `( V. D" Q1 qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& x: _+ X2 G9 Q4 }
dic={}
  T6 h  Y; g( ?2 b7 a) j1 wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 k5 E7 K  j' U& {  W+ a    dic[k]=v
1 L5 J! n3 m, l+ J( W5 z' X5 W- _    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
; P2 \. \) g9 j4 a# h1 k6 F+ `print(a)
b=a.decode('utf-8')
* c/ t) ?3 x6 O$ S$ y9 t) Nprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, W; ?/ i; r( u3 l: Kprint(a)
7 n. j2 F" W9 \1 hb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
4 I) X9 V+ f/ m* W* ~1 hsum=0
$ S! L' t- ]' J$ S- zfor i in range(100) :
    sum=sum+count
    count+=1
3 @, [* g6 ]1 M& U, V8 l7 F+ g; {print(sum)
! [9 t6 M( [7 q3 x$ G0 J* j3 j  m
; f) z& s  E9 G, i( V! |count=1
sum=0
while count<=100 :
# n* L: R; D% _- R0 V    sum+=count
! N8 e8 T, W2 b    count+=1
print(sum)29、元素分类
9 W& [, D. h- V3 `有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
8 g/ O2 L& f* k" E6 [将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
( b! k5 {0 N/ x7 U2 d    'max':[],
0 x0 `) a4 L8 d( @    'min':[]
}
for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
) n+ J$ g8 c& q/ ]* {print(dic1)
- Y0 e' e  `6 W0 K8 J9 N; D
, e0 R+ e6 i/ U7 K7 P---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}