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

. |/ d3 T; v6 v5 D; W+ F2 s4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

# o0 S! ~/ u. {( D. B6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
+ J% y3 X3 P) [3 B6 _. yz=1
0 S- T! w. M0 zprint(id(z))
& `5 N1 d$ J+ m. ?0 c9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

. I/ a( @, Y( ~  c& G4 h2 b10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
' r, w3 n2 C% ~# @6 Tname=input('name:').strip()
pwd=input('pwd：').strip()
* ?" @' f8 C  P7 Iif name=='seven' and pwd=='123' :
    print('ok')
# F0 J2 l4 S5 Kelse:
    print('error')
0 [  ?& r( _% y3 T
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
/ S( P1 ]* F! ^; p1 H4 o, J
8 q2 c& R* L6 _/ e! f3 t    if name=='seven' and pwd=='123' :
( D7 S% P$ c& k- e, o/ E- u        print('ok')
! m% V# r+ K3 f* o    else:
5 W! {/ h) e, U; r        print('error')
$ ~: x+ M$ c% u  B        count += 1
for循环：
for count in range(3) :
: w% Y$ @; r6 Z' ]' b! T    name = input('name:').strip()
    pwd = input('pwd：').strip()

# q; G! y- R  X3 u' r" {8 m" v+ {    if name=='seven' and pwd=='123' :
. Q. z6 t* S# `; y  c        print('ok')
) m- g; B. O/ l7 g5 |    else:
8 |5 s  C8 q" \        print('error')
, W! D5 e5 o- m) s$ C        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
4 Z5 l' T4 s- gcount =1
while count<=3 :
    name = input('name: ')
* }$ w( i: d/ G2 w    pwd = input('pwd: ')
2 m' ]) L/ w% p! F) A& P    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
. E! X- ?* E& _0 ]: W    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
$ `, M1 \( X0 d: \( Y6 ]        print('ok')
    else :
8 w$ [! L* q, s6 X2 O$ H: @! D        print('error')
* W6 N- Y. H" |9 s        count+=111、写代码
" t: |0 f! p# h6 e: q. e% u) za. 使用while循环实现输出2-3+4-5+6...+100 的和
% s: X" w; p( I' |8 ncount=2
num=0
while count<=100 :
    if count % 2 ==0 :
6 T# c2 _4 f- j+ \        num=count+num
2 R6 X5 L8 c+ N+ q5 s1 C# B" k        count+=1
    else:
( f6 D5 U# B& [( W" J4 A        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
7 }6 y9 M$ R: F num=0
4 A6 _8 C. j* W6 dcount=1
9 [7 F* v* Z5 B% n% Lfor count in range(100) :
2 `/ Q& w2 d. z5 S    if count % 2 == 0 :
9 F0 ~  @% w- @: P  K+ y! a$ d! w        num=num - count
$ |4 ?' }7 k3 \' \  L    else :
6 E5 M* D$ E- Y- ~+ I7 [6 s        num=num+count
print(num)

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

count=1
while count < 13 :
    if count !=6 :
1 q8 x. S6 Y1 \2 }# }        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
3 L3 P# _) D; |+ L6 n& P        print(i)

count=0
while count<100 :
    if count %2 != 0 :
        print(count)
    count += 1
& S9 M2 x. j4 U& e/ [6 q* R  c$ H
+ O% G% u$ h- P* c1 a7 T* ^e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
1 G1 d0 E" @4 `, o4 T% l        print(i)

count=0
while count<100 :
    if count%2 == 0 :
! l5 _5 Z5 _( f8 e' b; W        print(count)
+ i/ u0 g- f& w2 W2 I; p) K    count+=1

& O4 [4 r% m/ b6 [" j12、分别书写数字 5，10，32，7 的二进制表示
: o  y0 V/ W# s+ I! t9 e0 T
  |5 b9 O- u4 Eprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
) j3 U2 |9 j$ R  ?print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 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"
7 j9 n. B5 v$ k! g; H( fa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
7 E4 c+ V6 d, C* E
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
! m- \2 k! O. P; zprint(name.startswith('al'))
/ |) W5 V+ f+ k9 cc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
2 e& t" a- i# f0 Z6 ge. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

  l7 |$ y& @3 |9 Eg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

8 V& ^. s! X( |. Wj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
2 Q* z! S) g, m) I) y依赖索引
' d+ `' i; M8 ?% hname = "Alex  "
for i in range(len(name)) :
! l3 ~1 G0 \3 r    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
- K7 ~2 |  v, Z22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% v. B2 x, r4 \) h% N5 ~( A- |print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
. M. j; B9 C- Q1 y8 f0 _) X5 tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 K3 P; N6 G0 V# c1 b; g1 r6 dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' b. Y( d1 \0 ~1 ~print(li)
* z! G5 S3 x( {" A6 ^9 Z! H. ne. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
$ E- E- D# |/ u6 D( Rprint(li)    ['alex', 'rain']
. C; v: C5 h; @9 O  P指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
- `1 g# o4 L. R- G$ nprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

eric
( o* Q4 L. ~2 ~. `+ t' \% `['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& r3 Y3 P: ~2 K9 q  g6 Udel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
% X1 B% r; E9 F3 n/ A9 e, vli = ['alex', 'eric', 'rain']
! i5 H: n. v, a) t2 |8 q) @" ifor k,v in enumerate(li,1):
! b/ {$ X# n/ P6 _    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”
" k5 P) J$ [( ^+ s; |$ U' fli[2][2]='ALL'
# v% |3 f1 E8 R7 f- Q! ?" v+ F$ Nprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
) k) N5 j# i1 \- ~1 `/ w' `a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
6 k' U- T& i- P* H! j- v$ Aprint(tu[1])
8 h- T4 X; R4 l" ce. 请使用 for、len、range 输出元组的索引
4 F3 Q, ]" L7 hfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
" P" ~* i* R3 l9 E1 |for k,v in enumerate(tu,10) :
    print(k,v)
9 C  w# J# p2 Z3 p10 alex
( x& S9 f, D- ?: e' ]9 I0 K0 m11 eric
12 rain

8 Y9 j$ ]" D, D) t! x" @for k in enumerate(tu,10) :
, F4 ?# [% ~. O" X5 E9 z7 s" j6 S    print(k)
9 M$ [5 k3 I- T- _: U( L* }% Q(10, 'alex')
0 A! m+ a3 T* r! Q/ |% |(11, 'eric')
(12, 'rain')
) Y3 G2 T. S, q! r
% J3 I5 ]4 Q6 m" d) e, o, N
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

: f7 P7 V9 d! R' `  {% ed. 请问 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)
' g, w5 a$ ~$ R/ W. Z26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
( S5 O6 X6 ]7 }& W6 R4 mfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
) P( E' b3 o7 k4 Hd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& A) C6 N; M( d  Jdic['k4']='v4'
print(dic)
/ K$ ^! [3 f: f3 @" ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
" M0 h$ d1 f) ]8 M4 oprint(dic)

: ]' r( x; I6 J+ V: }$ xg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* \6 z& X) w( q& ?. e0 k) zdic['k3'].insert(0,44)
print(dic)
# ^( E4 X, B& J% j27、转换
8 ]+ t; {7 U( M2 ?: ]4 ma. 将字符串 s = "alex" 转换成列表  s = "alex"
6 A* K4 P& E% Q. S* d& N/ _
1 D/ r( g  w  e( Z# aprint(list(s))b. 将字符串 s = "alex" 转换成元祖
) D! ?& T8 |9 k2 W4 gs = "alex"
print(tuple(s))

! Z2 v+ ]6 ?0 Y) I8 U4 i* o; l1 [5 ^b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
' R" x9 C' m  g5 ~8 z# Xtu = ('Alex', "seven")
  E, u8 L9 x- eli=list(tu)
1 r2 {! s9 [( V; N) T: D& H* Lprint(li)
. H1 W+ j# f# [7 g, @, k) Y: a

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
4 O1 H9 N5 M  W3 k/ V& i4 i: @
# u$ o' ]1 R: x1 v; i7 {dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
2 i5 i8 X9 H3 a    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
) r& }& I/ y7 ?$ y6 G  H" z+ ^print(a)
! V6 R% M% C/ s+ S! B! n& pb=a.decode('utf-8')
print(b)
5 B5 k6 g8 m) A7 P$ J) t5 ub. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
) [. b/ {- A+ e# t2 N) R/ Q/ Iprint(b)28、求 1-100 内的所有数的和
0 h8 ^+ b9 Y/ s! N9 _4 h; dcount=1
sum=0
for i in range(100) :
6 l" @: c# O( ^9 S8 `5 T& }    sum=sum+count
    count+=1
print(sum)

3 C, ~+ ~# Z/ d- r* t% f$ w; Hcount=1
! M' ]$ I) W  R( asum=0
, q6 D5 C9 b4 W& p% gwhile count<=100 :
* ]6 o2 j1 Y6 V' v! U% [    sum+=count
, q  C/ I- s+ R    count+=1
print(sum)29、元素分类
( o! |: O: Q4 B; B有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
# K; p  ^' D  M4 Q: m) g/ a) n即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
8 s6 b" h5 N$ ydic1={
    'max':[],
    'min':[]
+ }. T. o& a# a: r" O}
6 w! K. I2 N, ^7 L( H* R& ]for i in li :
* Z4 [& g! Z" S0 W1 C    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
) P" ]) {  v; ?$ b9 V" V( p
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}