Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

( d0 }- U, j% y3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
+ M; d, V+ u( J$ j- ^5 c+ Y9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

( [$ c7 |' V- g; Q8 o10、写代码
0 B/ h/ p. r$ E0 E3 na.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
2 g/ a/ f# P6 _    print('ok')
6 _+ z( d& k  relse:
& r$ q( [7 @! d( [) W    print('error')

! h" I, B3 x$ t' }b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
2 |& c3 d$ n+ Gwhile count<=3 :
* e. x2 K0 F9 B# O! L    name = input('name:').strip()
    pwd = input('pwd：').strip()
- }. e/ Y# d2 }" x9 H% g: ]' P8 g+ i
    if name=='seven' and pwd=='123' :
3 e: ?/ L2 d: u; X% y        print('ok')
! Q+ v6 t: q6 K. J/ g/ }    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
- I4 t9 r+ s& v* B' ~    name = input('name:').strip()
    pwd = input('pwd：').strip()

' \; J& \7 r& }3 }# ^    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
* r. Y* D/ q, P6 g3 Z        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
' l( ^; S# s, w: X8 u! p; C: P7 v. q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
+ O' c( ]+ U0 |0 c# T7 y% N    else :
* F1 h" t9 F, b9 Q! W& o# V6 c% E        print('error')
0 H0 X4 @, ^; O5 t; e; b$ a        count+=1
for循环
* W2 T& w( W& Lfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
! T1 t4 J- ~# P2 F        print('ok')
    else :
        print('error')
$ l, E2 d! [. n$ n- [6 h; `        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
, O+ f, i* \  [$ M- b. B& ^count=2
* i$ I* v+ X3 F: p+ p6 F! ]num=0
( q: z& \. i5 G, D/ L: Hwhile count<=100 :
    if count % 2 ==0 :
: f9 p  Z1 Z3 Y* V" b        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
3 s4 N5 g+ W; G6 v. rprint(num)

  G7 N& e. Y6 K/ T) c( D" \b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
2 z' \& ?9 `. y$ F        num=num+count
9 V! L: w. U! g8 x6 bprint(num)

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

0 j% p0 C$ b9 n. S+ Fcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
" P4 z6 T/ q7 K- n* e3 h& ]            print(count)

1 R4 `/ s" y5 k4 K3 D    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
* w% s  U* ?$ x    if i %2 != 0 :
3 m. D* i) N; ^5 E* D        print(i)
4 ^9 H# Y* L2 h( X8 A4 h
count=0
while count<100 :
1 g" _; N: B3 b    if count %2 != 0 :
6 m7 f) U; N1 f& m, e0 S$ C        print(count)
$ N8 d% q. Y% z    count += 1

1 g+ \1 a4 Y( }" _* C! b8 b1 Ue. 使用 while 循环实现输出 1-100 内的所有偶数
( h& h3 W6 z2 q6 F6 U* m$ sfor i in range(100) :
! G4 z7 @4 V' I! v6 E' q0 M    if i %2 == 0:
! C7 w6 `$ b7 y" |7 k& {        print(i)

5 T/ T& b( H0 |& g7 {3 J! q9 kcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
, Q3 P7 I4 c" F9 U+ C$ X    count+=1

& L* S6 a4 G; L, n" p  k12、分别书写数字 5，10，32，7 的二进制表示
1 w$ B' ^! W# _
" Q$ ~% r$ f& D2 J7 i5 fprint(bin(5))二进制   0b101
6 y' I2 m4 L. I5 c! H1 qprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
/ W6 l' f5 m5 }$ c7 K* t14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

, r/ T2 Z# G( C5 _16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
* n( c. p0 X. r( n; N7 S17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
, R* g; [* E2 Z: Nprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

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

& ?% h8 G6 z# S$ |. t# r4 ^b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
1 |5 ]. x& ~9 Z) j8 Z6 i9 p7 R, tprint(name.startswith('al'))
! M% h9 l) T+ a2 ]' j- k0 Q, u' `c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, @" a* ^$ y) dd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
7 B( ~/ @. r9 H' T0 n& t; sprint(name.split('e'))   ['al', 'x  ']  列表

1 W9 U. p& S8 F! k) s9 G2 w3 ug. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

" e* J: z* ~$ U( t' ^9 Vj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
/ p2 I( x, Y& B$ L: `2 {: v5 rname = "Alex  "
) ]" A1 ?0 w. O* p' zfor i in range(len(name)) :
    print(name)
0 D! C8 c* p, J. Hfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
1 H1 \  h: s% a5 a6 Y4 j  ~print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
/ R  E2 _% j$ ]: P; X# w4 @; A+ Aprint(li)
4 g5 u' K9 \/ R# |% c* f5 X" L3 C ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
/ p$ X" Q* y! H) H$ Uprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
: L5 y) h1 }( V0 M0 g3 Yprint(li)
& M% o8 h5 f8 Z) }: x8 p9 Re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
* n5 ^$ j, b4 fprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
3 {9 |; M2 p  d7 b* R. D! Uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
5 P5 H( z; L* E  y+ t
eric
* I9 d* f/ o3 I1 G$ n7 T$ D5 I4 p['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: y; o  q5 X4 o3 H/ [del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 D7 M1 ?6 w0 l- a2 vli = ['alex', 'eric', 'rain']
/ d' s/ U. ^0 Jfor 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]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, W9 l3 {; z# F0 w8 g4 Lli[2][2]='ALL'
print(li)
) [$ H  ?4 Y% d* \24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
  V0 O  \+ v! c: B" ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, \! F/ q; L$ k1 tprint(len(tu))
$ J( H( G/ M6 f" Ib. 获取元组的第 2 个元素，并输出
9 @8 {) T: |  Pprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
$ y& b6 r2 L& _3 t* Y: ^for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
1 Y" j  V. D, n/ ?11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
; S2 a+ ~3 T  a" J2 w! M) \$ D- `(10, 'alex')
: s8 H8 B' Q: f  ?( @2 }# m(11, 'eric')
(12, 'rain')

, L( f$ S6 C0 _" J
, g1 J) }9 ^+ \5 K25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

* o$ W$ A0 ?/ P. }d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. M$ Y2 o9 V& t$ n. ~res=tu[1][2]['k2'].append('seven')
' F. g% F4 k( ^  e+ T0 Y# z: E. b
* Z7 |5 {; z4 g) @print(tu)
( A! T/ m4 s. `' y4 Y26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
# d( c; s6 ^' ifor i in dic:
    print(dic)
) o- M3 _; J% uc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
% `% k1 Y  r2 _: z' I/ L$ Ed. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) P/ J6 l) m- _- o* Qdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
$ `5 u4 W. d% L) d3 K/ g4 Gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 R) k9 J2 z1 \0 k3 p$ zdic['k3'].append(44)
2 w( L) c' m; @print(dic)
7 b2 z6 X* x& i
( F* F4 g* O4 t% @* u3 F  |g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

5 v; }. l  X# O! H' Kprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
8 x' e6 ^. y5 |" w3 r2 @print(tuple(s))

3 \9 l5 y! ~7 a+ z1 `b. 将列表 li = ["alex", "seven"] 转换成元组
$ G( W3 ]* V' |- oli = ["alex", "seven"]
2 e1 t+ ]7 G9 j8 ^0 M5 ]& Aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
4 D/ M" m2 [0 A/ T/ Q6 U. @tu = ('Alex', "seven")
li=list(tu)
0 D! T' k7 O' a+ j9 q( }) O# Qprint(li)
- K3 Y6 `% [+ _! }& Y, L
+ b+ I$ }4 z6 C5 _1 ?1 t
% N% }  Q) N3 c. P" i/ L. Hd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& g* E. _, q0 L* U7 m
/ F" G1 h0 f. F7 Udic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" z7 |7 ^5 p; k    dic[k]=v
    print(dic)27、转码n = "老男孩"
  f8 l& J* i" u3 P' J* u9 ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 \" k; @& N6 w% C8 |; Xa=n.encode('utf-8')   
' w* x, n; u: u1 e  Y# Kprint(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
/ j* Y2 G0 T$ h' L9 vprint(a)
b=a.decode('gbk')
1 o$ V4 g! ]/ ]0 ?8 b6 P' xprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
$ m9 c  d% S3 F2 sfor i in range(100) :
    sum=sum+count
4 b' m: H6 ?, D8 P3 R    count+=1
$ n6 B7 z0 p! I2 V+ Z' Rprint(sum)

2 H  i/ Z0 i' E( T% D6 k( Jcount=1
8 l  U4 i" t/ J) w/ gsum=0
while count<=100 :
2 R8 P$ l1 X5 ?6 G* M    sum+=count
    count+=1
. O  D% W1 S, Y4 b- {% _" f0 \print(sum)29、元素分类
2 W! V' x/ \9 k4 ?有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
: ^/ F" X( A: z    'min':[]
! q! K; y  m7 N" I}
6 l# U, W7 P+ V& E& ~for i in li :
+ h4 V2 H4 L+ w1 w& j! j3 f    if i <66 :
        dic1['min'].append(i)
    else:
/ R2 f6 `1 _6 f7 R: U        dic1['max'].append(i)
print(dic1)
: A. [# p% Z: O2 L; w+ |5 ~. z
6 ~/ i* d  l3 t% l; e" T---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}