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个字节代表一个字符，

  p$ u! d- P5 H! P# K: }4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

+ K2 Q' g, Y5 ~: ]. e5 q/ w2 Y5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

- f# W$ n! {5 U! Q. P8、如何查看变量在内存中的地址?
z=1
8 y3 s0 l+ f! O$ X3 X; f5 e: T0 sprint(id(z))
7 l) a/ f" K" m3 `9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
* Q3 X: ^' K. N/ p7 z2 C: I4 Ba.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
. h6 \$ d+ a7 v, ?0 Rname=input('name:').strip()
* T& n' T5 E, Apwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
  j2 [3 u% Y* m2 Q8 O. c    print('ok')
else:
    print('error')
3 J- t  e& r: s6 |6 Z8 c/ C8 v
% Y6 Z) n0 p+ A# s% M7 _4 h- X8 eb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
, z1 Q7 D2 u$ y6 p) ~; a    name = input('name:').strip()
9 w5 Y0 i4 W' X/ |5 M  G# K* r  e3 `    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
* e9 t- I& N: ?' B* V6 k        count += 1
for循环：
for count in range(3) :
% F: M$ x4 ~, N' e    name = input('name:').strip()
    pwd = input('pwd：').strip()
- D; a( r6 h) a
- g$ y' K$ B) y+ s; g8 [8 _    if name=='seven' and pwd=='123' :
6 K7 ]! `- X% J        print('ok')
    else:
2 [) u' {5 \6 w0 ^& F4 n0 ^9 j  n        print('error')
- U* j8 V8 t& ~0 Z        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
3 c/ v$ G9 ?# b    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
4 o- B, m6 F/ l& U% D5 z, H4 u/ [        print('ok')
( U  R/ K8 B  A! Q2 G- k: Y    else :
        print('error')
3 t* m2 @3 D. y; P        count+=1
! J7 W: C. \; `5 j) `! \for循环
' N& |2 r$ r, s  c# i# ^for count in range(3)  :
    name = input('name: ')
5 l- B( K* m0 a9 V- m    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
8 N" `4 n  U" Z& [        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
6 V$ B9 G$ t' ^" A( I( ~num=0
$ e" j) E1 S# t( y+ I3 g* Vwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
1 `: j7 |7 m+ e        count+=1
1 \. s- j: i" x$ A, a' m9 i6 h2 D8 t7 ^    else:
        num=num-count
        count+=1
print(num)
2 l" y$ o5 ]4 h( C) H( m! E# Y
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
- R+ N2 r6 b7 ]+ l5 w( a4 c num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
! o# d5 \6 e1 O( h        num=num - count
    else :
        num=num+count
) Y$ {8 v5 R6 K+ J0 d* w/ Uprint(num)

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

1 ]& r2 Q2 D3 D) I  e# {count=1
5 g" ^8 C; Q- E, {' k7 ^* x! Nwhile count < 13 :
. C: s& v3 S4 ^8 `# {$ o    if count !=6 :
        if count !=10 :
5 D3 C: W# R- B6 b/ d, w* a* Z$ b# N* q            print(count)
+ W$ G8 N+ g; v$ _+ Y( J
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
4 \% U* L; z/ [7 L0 q    if i %2 != 0 :
        print(i)

count=0
while count<100 :
    if count %2 != 0 :
) W+ g* |: O( ]8 Z$ ^0 J& u        print(count)
3 I1 B1 _" t- U; s9 {% h3 L% Z    count += 1

- @- Y2 Q* ~8 ^$ U* d8 }e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
: l$ k9 {: P, i' D" [$ b& ]        print(i)

$ m2 f' l% z) G  p7 L* m1 d& |2 \count=0
while count<100 :
5 Q1 W. ]& b, P4 C* s+ ~    if count%2 == 0 :
1 G6 O  f5 h7 s+ v        print(count)
0 O* F5 `: b1 E4 c    count+=1

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

print(bin(5))二进制   0b101
/ h) i) T/ m% P, `* j4 Eprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
2 l- [* q! R2 ?* t9 u; ?% Wprint(int.bit_length(n1))  结果  3

1 \/ B9 D$ h% j' Y18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
* q2 P5 H3 n( Q/ Fc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
  t/ c, @/ F8 i( |7 P+ q0 |5 `" qprint(name.replace('l','p'))   apex  
, |9 k5 H9 Q: z- P" K( ve. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
0 Q0 ?) h3 U8 u1 a! k" ^3 d
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'))
$ E' C6 T  X8 Z7 p" }) \21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
# ~# l( S# C2 n# sfor i in name:
# P4 `% g: M: g( n& f: g: k2 O    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
* c8 }" z: I' n, K2 l1 k  d22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, c; \2 @; @, f3 i- Vprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
8 H* L$ j5 U* R7 ~print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
* Y% {5 ?) I* oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
' l% m' A5 {) a0 ^5 m, X- N5 q; Re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
% n( M' i( s- c8 p( l指名道姓的删除li = ['alex', 'eric', 'rain']
9 d1 d( h5 T0 q" x2 S* Fli.remove('alex')
4 C- I( x3 U2 ]  W2 iprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

7 H* O; _4 N4 O) Q0 n0 C% Ieric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
  g" l9 {$ S/ C$ z: n+ rprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 Y. e$ Q$ [+ D) q7 uli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) ^; M" z  w0 B( R& W: ^- Na. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
7 x. f" R6 _' c0 Eprint(li[2][1][1])
# n' L0 l9 ?" vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
9 R1 a5 c0 E; T5 P# Cli[2][2]='ALL'
print(li)
5 O8 }2 u7 [, G: z- F4 \" w5 o24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
" A! C. o. [6 ?/ d+ P: E+ F& ra. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
, p" }& v) x0 k, J/ s1 lb. 获取元组的第 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) :
( S8 n  ^5 V9 u# I( M* |# ]1 ?    print(k,v)
: \% N  a1 G! z  C7 `10 alex
11 eric
12 rain
- H4 e- ], h, [' d. ^" R
+ ~, V  |3 D6 ?3 h& k, vfor k in enumerate(tu,10) :
0 f( b* T8 C2 c0 Q9 Z. ?& R) e0 p" R    print(k)
2 t5 C$ x6 K5 R(10, 'alex')
(11, 'eric')
$ L& A% o" j; ?(12, 'rain')


% b5 ?3 \  {( ?5 j( ~. w25、有如下变量，请实现要求的功能
" k7 b3 z; T7 z; u: f! m0 mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 [% q# t: g+ j! a# I2 S8 htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
' I3 D* N8 h9 `# B: ires=tu[1][2]['k2'].append('seven')

print(tu)
% B$ v& \2 f) l- G0 R& t* E  k26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; {. Y/ T$ ~7 H, b7 ]/ u8 `    print(i)b. 请循环输出所有的 value
6 d1 |8 H' u: X  h: T9 I' l4 _for i in dic:
    print(dic)
6 c* n0 q% s6 O+ s* w2 I% K) sc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  g5 D6 B; f) B" t: u2 P0 _& Q" Ldic['k4']='v4'
print(dic)
9 c. A& f9 B. s( ?; }& Fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 C6 ^# Y4 Q. q+ S+ ndic['k1']='alex'
$ `, P: J: ^8 H! m2 ^1 X6 h$ x5 Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
1 i9 v7 _7 M/ h8 c
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
7 j1 ~1 o2 Z) |. A8 ^) mdic['k3'].insert(0,44)
print(dic)
" }  {) b3 l* ?0 p/ s1 p27、转换
6 K: k* E6 W# h  B6 `9 O- [( y: B1 |a. 将字符串 s = "alex" 转换成列表  s = "alex"
, w& _. J% B/ `, `8 x
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 A/ U% @- W2 x6 ^! Is = "alex"
print(tuple(s))
" }+ q# O' y. ?; h' x# v3 K0 Y
% |$ d$ K$ w* }& s3 Db. 将列表 li = ["alex", "seven"] 转换成元组
/ W1 U9 @9 w6 m6 i( P) ~# Xli = ["alex", "seven"]
  Y4 Y2 f, t; W" u8 vprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
5 T3 x4 t+ d+ G" F. }tu = ('Alex', "seven")
li=list(tu)
print(li)


d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. N& H4 d" x+ Q1 x
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
: {: W* I/ Z9 l; `& h, z3 Z    print(dic)27、转码n = "老男孩"
0 ]3 G3 j0 D) ^4 V4 {a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" [/ \/ v2 \" }1 p& y( q) k6 Q$ ia=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- w' `% @% J) `print(a)
b=a.decode('gbk')
0 R9 Y+ y8 s* g" `8 r9 O2 aprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
8 T; l3 n7 y! u9 d. G    sum=sum+count
% N3 t1 S! X2 `# [* O    count+=1
. ~) l' o$ i# _7 [7 Bprint(sum)

& Q- i3 R+ q- Kcount=1
4 U! O, Z& y* Z0 s& T1 e! V* W) [. ysum=0
1 I. ~% T% P( _" s8 q, g' E' K& Swhile count<=100 :
1 `! x, A2 n+ h# O1 V: D2 V    sum+=count
3 }1 o; n. Y: m6 _( ~1 A8 O+ L    count+=1
1 T, X& a4 C# u! g* Eprint(sum)29、元素分类
- o# J( b! {1 A% \有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
* y' Y/ c5 j. a7 K  \% K5 I将小于 66 的值保存至第二个 key 的值中。
( F! F# P" A; y, u+ V即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
% p- U) q: n3 b$ i7 wli=[11,22,33,44,55,66,77,88,99,90]
dic1={
6 |7 \" j+ S) T- L, U2 d6 x7 l4 x    'max':[],
    'min':[]
}
for i in li :
/ l5 z& l* U% o. M0 U9 H, ~    if i <66 :
! U& O, b7 c; p$ _/ U$ @9 r* H1 x        dic1['min'].append(i)
6 a( O  T& ]' d/ M: ?    else:
        dic1['max'].append(i)
print(dic1)
$ u% a' X/ k0 ?# o
. T7 ]0 ]  |  t4 r5 Q3 p; n---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 t3 T6 W' a* h. j( `