Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

" E% w* d% u  s3、简述 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

/ u2 a. _' ?0 f$ f- V1 ~+ J5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

' K4 G6 [8 ^4 p/ k8、如何查看变量在内存中的地址?
z=1
) r. l9 S% Y& k; o+ U9 V* |print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

" J8 ]. N% F5 F! [- [$ N  ?( H7 Y10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
/ F* x& s' u, g# W  jname=input('name:').strip()
pwd=input('pwd：').strip()
4 ^- o9 f% P0 r7 t/ v$ g: jif name=='seven' and pwd=='123' :
    print('ok')
( V  \, W& S: Q3 {2 l  c" l" d3 Qelse:
) U* N/ h% N0 n9 I+ D' w% H4 P    print('error')
1 h" \/ z; _) a* u* T
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
) U1 q" C" _5 p! r" D/ i9 A7 qcount=1
while count<=3 :
" T, U# R# H3 z- j- B2 n    name = input('name:').strip()
    pwd = input('pwd：').strip()
6 n* @, U. g! I3 l, r
/ y) E/ z9 L& l# G0 Y6 @' g9 `7 R    if name=='seven' and pwd=='123' :
! v0 J! v  t2 n' K        print('ok')
7 A9 j5 C3 V- m& f3 {" C    else:
        print('error')
        count += 1
* ~: t: Q  C! \; P5 ^for循环：
for count in range(3) :
+ Z; V& }- a' u( N3 ]3 A    name = input('name:').strip()
    pwd = input('pwd：').strip()
: o: R, G! i6 |% Z
7 c; l, d  _! ]" M    if name=='seven' and pwd=='123' :
, r5 p, R! ~0 C1 |' Z        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
9 S+ {, m: C! N1 z9 d/ v! R" g! Ccount =1
while count<=3 :
    name = input('name: ')
9 I/ {5 `: x; h; ~  T" A    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
4 j6 `2 C1 Z. a  q) b7 K    else :
        print('error')
' @% b0 o4 {- q, y2 H$ T* f. }, {        count+=1
" e* V; h( M$ @' S/ E. Sfor循环
for count in range(3)  :
! I2 K& W" M/ G    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
0 k) `- E0 o! x        count+=111、写代码
, R& b9 [; i9 w9 n! D4 L& p$ [a. 使用while循环实现输出2-3+4-5+6...+100 的和
+ ]% S7 i& [9 ]0 n3 `2 x' A; h' \count=2
1 M* Q* \- ~! U. J) r) Q" T* W. Jnum=0
while count<=100 :
& J8 o. A/ j  t    if count % 2 ==0 :
9 h  j+ K, j. q. z- d. F        num=count+num
        count+=1
" g( J, b- `! ~: Y    else:
# C  A3 k- _  m* x        num=num-count
        count+=1
" R6 S8 U) {: i  N' f6 |print(num)

1 g  m; m% g3 e1 g4 ib. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
  N7 ]5 [* [8 L- Bcount=1
9 }8 j3 n6 I7 g; h* O, ofor count in range(100) :
    if count % 2 == 0 :
4 P( a& K7 |" b6 o, x6 b1 I0 q2 q        num=num - count
    else :
( p0 V# O; p3 u" c( d& |% D" r        num=num+count
print(num)

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

* m+ N9 I: t0 Y3 @8 b( Vcount=1
$ u. n8 U( j1 }  X, E  h2 `  J) m" owhile count < 13 :
# {! m* A! x% m8 V    if count !=6 :
        if count !=10 :
) M; g& m( G% i1 s) O; Y& f            print(count)
  ?$ z0 m: r: V0 D2 I' T
! |; q. c( d; y' V' y; S" s. s    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
while count<100 :
! k" x5 ~! A, Z4 U2 t$ H- O    if count %2 != 0 :
        print(count)
    count += 1
0 @) s  s) _$ ~
e. 使用 while 循环实现输出 1-100 内的所有偶数
% f/ H4 f% Z, \, W2 M2 [for i in range(100) :
& l9 L: j/ ~6 y# ~    if i %2 == 0:
        print(i)
. e8 B, p$ M" l8 c
count=0
: B: ?" b6 @# S1 }( v* {0 Y* W+ nwhile count<100 :
& h5 d; q5 F) ^3 b8 f1 i. K6 `    if count%2 == 0 :
        print(count)
6 r( u; ]4 [1 \0 \- H- S! T$ e7 h2 h    count+=1

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

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
- a/ F& m: I' g, L9 ]1 D3 C* u6 Pprint(oct(5))  八进制  0o5
8 o, V3 D2 \2 u- t14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

( e3 H' B% v0 E16、现有如下两个变量，请简述 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())
% {9 U' H3 l- b
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
$ u: h* p4 n1 X# u7 D' [print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
( o6 k. G7 c5 J: Q+ S. l. Td. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
. t. s% E0 n8 Gprint(name.replace('l','p'))   apex  
/ _* d6 c9 Z/ G2 i6 Ie. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

& g# U" K6 B0 m: M6 Z4 j+ i/ Y0 vg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

) L% C& v. w" e2 ~0 K6 zj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
& n3 {5 w1 }; w9 H$ W/ V, d# s依赖索引
  T: S' r5 o) f8 H0 Dname = "Alex  "
( j( l) K4 ]5 g% V  Y8 i6 V* Z- h% mfor i in range(len(name)) :
, H) J: Z; D. H8 y/ l; \    print(name)
( i# Q: o$ {; C" X8 g' afor i in name:
3 m0 X! K0 ^) A" y' k    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
- ?7 V  B# N9 |7 _8 e ['alex', 'eric', 'rain', 'seven']
, m+ F; o! C" A% K1 K, Y! ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# F9 V  p/ b7 B8 Gprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
# b( j1 f9 e2 h0 ue. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
: W, d% Q& I# @8 fprint(li)    ['alex', 'rain']
# G$ e1 |& z# i: I指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
4 U3 u8 |. c" b6 L5 x* Jprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 h7 H- b) p# jdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
3 h/ L$ U5 \' t: Q+ D# a- `. Uli = ['alex', 'eric', 'rain']
# h- E6 i- ~, e  _$ P& h$ C  Ofor k,v in enumerate(li,1):
+ ]5 ?' M* N# `* ]) F. B    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& C0 N1 w9 l3 \$ g8 C; s, ^) x/ ha. 请输出 “Kelly”
5 Q+ @+ G/ u. r5 n" _' U9 x4 Z$ _* kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  ^/ w6 g. I6 g3 Z+ Tprint(li[2][1][1])
4 q) ?' e  }1 i, T; `b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
) j0 A' y* U2 ?+ |1 b4 zprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
. }/ l! {% y4 i2 w7 i) za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
% i7 s6 J% u$ K$ f7 H' Sprint(len(tu))
) D0 a% l' f$ j0 f1 T* u  G4 ^+ Ab. 获取元组的第 2 个元素，并输出
6 z8 e  i7 c2 F6 o( sprint(tu[1])
0 i- X! K) Z/ Y+ C& K7 {  H* X8 |  @* fe. 请使用 for、len、range 输出元组的索引
/ d+ d1 Y( r6 @) ^! {for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
! w6 N- {0 q5 v! b1 e( |for k,v in enumerate(tu,10) :
3 Y# x9 k% T/ ^    print(k,v)
& a( l, G' \' F' h" H10 alex
( j7 p. |% m; v' i11 eric
* A- H; \1 ^# _1 p5 b# c+ [( F2 H12 rain

& m4 i/ p, g) tfor k in enumerate(tu,10) :
# q  x9 H8 \. |4 r4 k    print(k)
(10, 'alex')
(11, 'eric')
( a& `' [- m4 J& k3 G(12, 'rain')
, u% _- ~& z: {  @. ~1 A. X
+ B) w2 d: E- ^8 K
25、有如下变量，请实现要求的功能
6 k) G( c1 h2 n9 q% xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
) _; e2 }1 E2 `  R8 W/ ttu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
2 A" V: h/ a. b; o) k& _res=tu[1][2]['k2'].append('seven')
0 j7 V$ l/ G4 c6 v6 J
& @" R2 a6 F/ ?; iprint(tu)
6 l. ^! B/ {4 Z# e; P26、字典
. z& J- c/ F. ]- ]0 F  q0 ^; ]dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
# u# |1 @5 T% O' ?5 r8 Y3 ^' ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
8 h8 d  C! y4 Z: {! u* u/ v: `8 _print(dic)
0 a; f( {; Z0 ze. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
. |# \# a/ D( W1 Pdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
/ i& \- {* I+ fdic['k3'].append(44)
: ]# o8 ~7 v0 F. D% ^; a0 g- Sprint(dic)
# z1 M' X$ `, b1 ?
& {2 R0 J2 Q( c  l& a& }! g* _4 wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- B; t" ]+ ?( H+ ^7 udic['k3'].insert(0,44)
) ~9 m+ N0 A) O" `( Qprint(dic)
27、转换
) [/ V" n9 Y! h  g% q2 W! ^a. 将字符串 s = "alex" 转换成列表  s = "alex"

! B( g/ w2 n1 T4 S2 W& g& g& o2 yprint(list(s))b. 将字符串 s = "alex" 转换成元祖
. |# k8 K, M: g* Ss = "alex"
print(tuple(s))

* M5 s$ n: P! ]9 q; ub. 将列表 li = ["alex", "seven"] 转换成元组
5 b1 w' `2 \9 v2 I, U5 Uli = ["alex", "seven"]
  s0 B  q8 K, y; Z1 L  o4 Bprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ Y: a  `6 Y+ D0 S' t- h! Z- }tu = ('Alex', "seven")
li=list(tu)
" j& Q3 f. Q, h$ d! W, Yprint(li)
9 U$ b- R  ~6 _5 L3 H2 F  }

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

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
6 Q5 g$ k9 d$ @" S: [    dic[k]=v
    print(dic)27、转码n = "老男孩"
' [' d, t- }' z& Z+ e& ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ i6 ]8 p  r' G% Q, `4 xa=n.encode('utf-8')   
print(a)
! f2 c0 a/ K+ k) n8 S5 u9 i1 ~+ ib=a.decode('utf-8')
, [1 V% K& B4 F: j' vprint(b)
* O1 I) a8 T! l  R. |b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
8 y  A& q# r; ]9 P8 Q. f: Rprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
( j' M/ A8 o9 C/ w% A/ ]3 R: G% hfor i in range(100) :
1 g) A8 m# F, v4 m6 V, B# O    sum=sum+count
( C# N1 @! ]2 Q5 c2 K1 o    count+=1
1 y# `" _  B) Z- L: bprint(sum)
8 B" k( g0 a/ f  W
3 A: f+ S  [0 U6 C% K4 M) u2 L& z( ]count=1
sum=0
/ t% W: e, C. @9 ewhile count<=100 :
) Y8 P- u! |% \5 J    sum+=count
    count+=1
; q' y% }7 U3 wprint(sum)29、元素分类
% J* W, a$ ?% d* o, v) b* q  X有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
3 x  e# V6 |& wli=[11,22,33,44,55,66,77,88,99,90]
: S, P* u* B: T$ [8 ]/ `dic1={
    'max':[],
    'min':[]
; A8 P' p* p% @5 `}
for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
% d& X0 |% w$ H        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) c* l6 J! E0 _, q( \# a( B