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

单行注释  #

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

" A' s3 \8 `( h( l; @6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
8 @" L$ i. R' f% B" q4 ?0 U- N- \print(id(z))
, G& A5 [: E* `9 a- ]: `7 v; N9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

6 f! P' ]7 L* q. W10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
  ?# b, D4 A" O& Bname=input('name:').strip()
pwd=input('pwd：').strip()
2 o$ p) [! A: V7 r% V7 B1 A9 Bif name=='seven' and pwd=='123' :
    print('ok')
) f0 I* h# f& ~6 I. O3 X$ welse:
! }: Q5 c* c5 C; |4 c    print('error')
1 ?5 y: r1 N  o3 m! x
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
( q" I3 E/ W! K' n) d# hwhile count<=3 :
2 g' g2 f5 @& y8 y7 s    name = input('name:').strip()
- B7 l4 L4 u- i" K  r    pwd = input('pwd：').strip()

, l9 F3 [  ~4 Y1 [0 ]3 m/ e: K    if name=='seven' and pwd=='123' :
        print('ok')
' X8 y0 ^4 ?9 s$ n& b* R    else:
        print('error')
# C8 m, p" l7 `* A. ^- V        count += 1
9 b$ z) T. v" f2 [$ k& S, cfor循环：
+ W% z& j  H0 W# ^for count in range(3) :
    name = input('name:').strip()
# e$ X/ j$ p; v! u& q/ ]# ]0 X    pwd = input('pwd：').strip()
, v" _+ V* x/ B/ b* |1 z* o: l
    if name=='seven' and pwd=='123' :
- C. ^/ D8 P9 Y# d5 A. y        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
4 K) F4 C4 p: f" n/ owhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
0 z; E( b* z- R    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
/ ~# w7 k1 Z3 S& A$ i( @: r( |        print('error')
4 F  ]& A# T( z# a1 M        count+=1
4 n2 ^# N* ~( Qfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
% p5 ~0 ^/ n, ^7 K- `5 V) @    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ |; d8 R: ~& R# d: `4 }5 c        print('ok')
& k5 ?( M1 p6 k" F    else :
% J6 _& J. V6 i/ R( J5 v        print('error')
3 i; z% J  N& b/ v" }; H5 }& I$ T        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
7 p- P' T! W4 d& Icount=2
5 `( W1 a" l' h' i3 l- \num=0
+ k; p; C; O) L' Q2 y, E  zwhile count<=100 :
5 e1 y% G( i6 ^; s4 c7 m/ d    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
; U: r2 k* P' [( O' r* Z! U9 b        num=num-count
        count+=1
print(num)

: m& [2 D/ O% s. z6 o6 Ub. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
. _/ j" Y5 O4 w/ A    if count % 2 == 0 :
        num=num - count
    else :
1 E0 p: K) ]& |        num=num+count
' G  w. ^. f/ ^. F( l3 Fprint(num)

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

7 w4 C2 R) O6 L; v" e1 rcount=1
# Z0 ?( H# ]( e: {  K' twhile count < 13 :
5 O  W4 D; X, i    if count !=6 :
# x. d$ M( Y. ?* y3 U8 f+ p        if count !=10 :
            print(count)

% o$ R& A1 r# v    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
% a, ]6 L- e+ w: c$ n, {1 s3 xfor i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
/ n5 {  i/ v4 {0 C, R; o+ Owhile count<100 :
6 k* `3 _. Q+ S. ~! S$ Z    if count %2 != 0 :
  W2 ^1 H/ Y7 x0 t        print(count)
$ d! z( e! u; o, I    count += 1

2 ~- d" o+ t! A1 N) v2 T, c& Je. 使用 while 循环实现输出 1-100 内的所有偶数
  }% p6 Q: ^3 G* Ofor i in range(100) :
' s5 F2 F' B+ A. d    if i %2 == 0:
+ _0 @- J9 l  }3 E        print(i)

' c- U4 E3 Y  @( c9 Ycount=0
0 D) d5 p. l; V% L; D4 Qwhile count<100 :
# n2 a) w. Y! Q3 w    if count%2 == 0 :
        print(count)
    count+=1

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

& E" H7 d/ y/ p' F' S1 d6 aprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
' s- T% d1 c6 Dprint(oct(5))  八进制  0o5
" Z) W5 o% I$ `% h8 _8 r14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

2 ^. ^6 d- G/ g$ z; b16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
  ^: ]  y. j, g. V17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

# ?& N# h' ~1 D+ \20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
, A$ ~  t2 c& a" R, z. Y3 B
) x4 T' _/ I7 o: C- M! s- nb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
0 i: Y0 p7 a" y. g2 fprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
6 h3 A# q; |3 l4 j# \' I6 U/ {e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
4 |# k1 a' v- k
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

3 A6 s/ k/ p* d$ q2 vj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
* Z. T  W1 K" {1 E# {& rname = "Alex  "
for i in range(len(name)) :
% n6 K. l" E5 S$ \9 S2 L    print(name)
4 o; R0 {% a7 ?5 X! e8 hfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
3 j0 u* H/ G3 m% x4 M1 h22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
" G- K0 ?5 w/ X9 |! c3 Yc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
6 Q0 v: J3 ]$ |& k: I! Ue. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
4 L5 N6 D) ?2 {* a8 Y8 q5 L* X8 A6 [7 }print(li)    ['alex', 'rain']
( r1 A. q& Y/ ]3 [2 e* F. X1 j指名道姓的删除li = ['alex', 'eric', 'rain']
% o% T: p2 Z2 p+ U0 z9 A" nli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
1 Z% s% S5 Z" y$ S
/ f; v: T: k7 D& P! i& R5 g; Aeric
2 h9 [. ]/ A) h% q. C3 z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
( T# e" K6 u; M, S1 pdel 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]
! T5 z. f( S' w& V* F# H3 Ka. 请输出 “Kelly”
# c$ l" L- U8 {li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ i6 y3 j' N! F( z/ M9 Z1 Aprint(li[2][1][1])
0 u! `3 i( q* X9 ?# D7 O6 l$ W9 k5 zb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
$ k- k" S* _9 }: Iprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
+ m: w4 l6 f7 A& ia. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: H7 s3 @6 h5 M+ H+ P2 Bprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
* l6 P+ @& J5 N" `for i in range(len(tu)) :
/ z% H. L1 n7 p  u    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 A2 z# O6 l3 C, v" p+ W/ \! m1 _0 Qfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
12 rain
- v. G4 Q/ q* q7 P* m
for k in enumerate(tu,10) :
4 k" m+ z& ^! Y8 b9 X8 y    print(k)
(10, 'alex')
" R: Z: ]8 f$ Z! E0 h. P(11, 'eric')
(12, 'rain')
3 l4 e0 L9 K! O7 k

- s4 o0 k2 X9 i2 g/ `3 u" Q25、有如下变量，请实现要求的功能
3 D$ e$ P* w. @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')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
3 I" ~3 U7 O+ a2 \) u) ~# Z2 ^' Jfor i in dic:
    print(dic)
7 M* ]1 Z# J; \% y( j2 Qc. 请循环输出所有的 key 和 valuefor i in dic:
& m8 p* Z; ]' g* dprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
0 L- Z( ]+ F* N8 }7 Lprint(dic)
& _7 t" ^0 m1 L0 de. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ g  \* z4 g, \) y8 i3 f: _  bdic['k1']='alex'
/ i1 {$ H; d& r! H4 xprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
" j* ]5 V2 G  Cdic['k3'].append(44)
print(dic)

) v" ~! b, V! Y2 `, Bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* o3 ^9 B& B/ {dic['k3'].insert(0,44)
print(dic)
. z: ]1 N. [$ B27、转换
3 d3 P0 Q9 K/ t7 Pa. 将字符串 s = "alex" 转换成列表  s = "alex"

8 t: h! `& a* w9 T# a- p/ U. {print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 G; f' v0 e2 F! z' B# o% rs = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
. O1 r" K) g. b$ mli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 c3 E( J" [: z: G0 Ztu = ('Alex', "seven")
; X) x: U, M- Z: J' Qli=list(tu)
4 o3 z/ |) c" x# v& [+ d) qprint(li)
. |$ m$ k$ @9 p. v9 X9 B8 J

/ M7 @  M; D. M, z  u$ ?d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

. F4 J+ j  n* _7 \$ r& |dic={}
% O2 O1 y) a, n8 S! }( Ifor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
6 I4 i( B/ j+ Q8 Y( h* K4 x: T    dic[k]=v
    print(dic)27、转码n = "老男孩"
1 a# b' Q$ ?2 r& h8 Y& ~a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
+ ?! L& q& @; y( {* N4 lb=a.decode('utf-8')
print(b)
4 Y# ~  D' T$ ]1 ?b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
% S( w/ H2 X# v9 xb=a.decode('gbk')
* E% }, w% l: {. h* Iprint(b)28、求 1-100 内的所有数的和
6 ]6 t% g% L, D1 a& l6 Jcount=1
sum=0
for i in range(100) :
    sum=sum+count
2 {' C; ~& y% A( ?. y2 ~    count+=1
print(sum)

3 r6 U! l8 ~5 [5 {5 @6 ccount=1
# s5 h  g" P! msum=0
while count<=100 :
& D1 n/ I- O- D    sum+=count
; N* B" ?7 e! B    count+=1
# T- o% i" [( X7 [/ M5 p) Kprint(sum)29、元素分类
7 R4 _. _7 a% I. f+ a有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' h2 J9 j0 i+ a, I) s将小于 66 的值保存至第二个 key 的值中。
  F& L: j: D3 `! h$ U/ T即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
2 z4 H% q' {% m) I( g; z. M0 R; H    'max':[],
    'min':[]
7 J& _/ J2 \4 H2 o3 x5 ?! j}
# ?8 ^- x2 p  Y# Y( Pfor i in li :
. H6 l, k; T6 p+ A- k    if i <66 :
        dic1['min'].append(i)
    else:
: ^% U1 R% I1 m4 \$ K        dic1['max'].append(i)
8 Q7 `! Y6 t& M. yprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
; k5 U+ s5 b# s1 I