Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

+ r; i6 \  R8 d% A( V3、简述 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个字节代表一个字符，

. W  m* n6 q- \; c! T0 X/ x4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

+ N8 }( s4 p  U' i9 Y# @6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
& ]( w/ ~) V# xprint(id(z))
. R/ L' b' |) w! U  U" `. i9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
; `% A7 y* H) j9 `% Q& {7 i% Wa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
4 W1 C; u5 B! Fname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
; L6 a4 P. y% u; U. q    print('ok')
' j6 A# o# d6 o- \else:
    print('error')

- u3 u! _: n+ Jb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
* c" B; K' l1 U7 Z; k7 Y/ c    name = input('name:').strip()
    pwd = input('pwd：').strip()
) Y5 O& J  K- D( ~5 `. w
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
5 v: a3 ?1 b/ ^4 y! y        count += 1
' X- n, E8 K  m6 I' Y9 Bfor循环：
for count in range(3) :
    name = input('name:').strip()
  m0 a9 L6 d; Q9 R$ R9 \    pwd = input('pwd：').strip()
* W( g( {+ m" ^7 \. x5 Q
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
& x1 v. d' q% C/ @3 ]' Z        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
" F4 G7 A+ c& p% hcount =1
2 ~; P1 M9 B7 swhile count<=3 :
* f; L( h% i/ q6 H    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
* [3 D9 y: ?" W" {( q) ]        count+=1
+ t. F* ^7 [2 O$ j1 m# S! {for循环
for count in range(3)  :
8 W! U; E" J9 V" z  H    name = input('name: ')
    pwd = input('pwd: ')
$ f. M2 K, D/ @    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 B- W7 L  V/ Q6 y, g% T/ P        print('ok')
: z. d2 g( {3 ~4 d$ I1 J/ M7 x3 ^8 G  ]    else :
/ `/ K: P2 D/ \( u( A! O& K        print('error')
$ M, N& @+ U* U" {; |        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
4 s- M1 `) Y3 c! ^8 O+ scount=2
+ Q. i' s/ ?; }3 y% i8 T6 ^7 `num=0
while count<=100 :
7 T1 x! L! S0 @$ i5 u    if count % 2 ==0 :
        num=count+num
# O& J6 E, V2 e        count+=1
    else:
! }+ i7 o9 X5 l* ^# u8 C        num=num-count
        count+=1
print(num)
; I5 n. d" ~) T# t. B9 d5 M8 r; m
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
; `% n/ e! l) Ncount=1
for count in range(100) :
    if count % 2 == 0 :
- h1 [6 }/ ~. O' H- Q$ \! w9 Z' l        num=num - count
    else :
) {" c) c/ o! J4 o- I        num=num+count
print(num)

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

count=1
while count < 13 :
  L  C8 ^$ m+ [% [; R6 k    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
. o' P" }: ^! G% D+ R: {% D8 ?for i in range(101) :
, y/ q. e8 q. H    if i %2 != 0 :
        print(i)
2 l' C2 h6 s& |- a9 E; k% {
count=0
while count<100 :
    if count %2 != 0 :
        print(count)
    count += 1
% M! ^) v$ z: r( ~- K$ p  x
e. 使用 while 循环实现输出 1-100 内的所有偶数
" ]4 }2 m! M0 w4 vfor i in range(100) :
    if i %2 == 0:
- X4 ?- W* N* a2 D, V- A        print(i)

count=0
while count<100 :
    if count%2 == 0 :
        print(count)
  E, ^# h9 a4 i( E, a. F    count+=1
, l4 [0 t! {6 i1 l0 \, J) x
12、分别书写数字 5，10，32，7 的二进制表示

: o- m4 T) Q& c- {print(bin(5))二进制   0b101
9 p' T  a' r( _6 J! R+ bprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

) r' V; h# ?1 g  i5 |1 P16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
, z: F% _6 D* ?# l/ W. w17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

. |# f; p% s  O2 z. e18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
5 k! Y) l& o' q7 `; b# za. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

( a: Y- ]7 F$ y9 Q% x1 t" U& k% q* q* N7 \b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
6 [0 z" @& u+ Nprint(name.startswith('al'))
8 a3 `7 J2 z; z. ic. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
& W7 ]6 h7 t9 Dprint(name.replace('l','p'))   apex  
7 t/ k! H0 P, n$ H7 K; w9 ~e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
5 [* o' v2 u  J9 E* f
4 S* L: w  k! x. gg. 将 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'))
3 \$ M; Y- Q  V21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
* o4 d9 _, |+ a( B9 e4 v) ]3 p4 f依赖索引
- j$ \+ a; z$ Y, c( H3 X. E% Vname = "Alex  "
( f' T% P' U% P9 Qfor i in range(len(name)) :
    print(name)
, h7 F0 B+ p/ i, C* j6 Ffor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
5 e9 `$ z( n# `7 D5 l& H22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
2 w% B# m5 G8 }5 K9 p% w3 J ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
) Q' p" ~# K! a; |print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
5 v( A$ m% c3 ^- d$ m3 ^5 ]; ~e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
& i. Q7 l  G, W$ N5 `li.pop(1)
print(li)    ['alex', 'rain']
# N. c& S* y; a; q" i4 U指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
: U0 E$ b) M& ~2 w* y9 s" j9 Rprint(li)
  X2 S- s3 F7 ]0 @& @6 Cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
# }' p1 a. \  `* A. vprint(li)
* R8 V4 k, B4 g
eric
5 W1 w' D1 m6 S9 G) Z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 N/ S! H1 e, h- ndel li[1:]
2 q- s7 S/ ?% }% W, N, Mprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& e1 U( V. o; B: n9 h( n! ~8 Xli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- g9 i: ~% q/ J/ u; ?a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" u+ ]* |2 N9 pprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
4 ~4 H9 f* m" x& tprint(li)
1 n, t/ u! L  N! f7 _2 D' u24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
4 O4 k! ?6 i- ?* v2 H, }  Sa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
, j- C5 w7 L: F* ~- @8 t# Q2 Bprint(tu[1])
6 y5 h- H  i( h. de. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
12 rain
( h. P; W% u) B5 j
for k in enumerate(tu,10) :
    print(k)
* r4 a  q1 l7 ~$ S8 s4 l0 x(10, 'alex')
( A4 @$ k  i2 Y; ?) }0 P, T(11, 'eric')
(12, 'rain')

" e. y9 f0 }! }" d" q% `
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

" K! G9 d1 C! Td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. y" W' M9 o* |$ b; eres=tu[1][2]['k2'].append('seven')
3 o: T) V2 O4 t+ k* H* x
6 v0 ]& q* r% E& G  U1 h0 ^" s  Vprint(tu)
0 r# ?2 d$ g8 K26、字典
$ q! c5 Z6 v) X* T" h- Odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
7 _1 [) y+ b7 B* a5 ^for i in dic:
5 a# u" r# i& \    print(dic)
' D6 ~1 u: a& u7 `" vc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
$ W2 I( e/ Z# a) t, Pd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
7 f: ]5 s* _9 W7 @, X# zdic['k4']='v4'
print(dic)
. P1 _% m: s! _: g4 l- S# n/ `e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 ~# e: }' {+ C  R0 }/ @2 cdic['k3'].append(44)
/ o0 Z* |$ o2 |5 S% H/ Xprint(dic)

1 S/ m5 D3 P  o- U  y0 ag. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
5 D" M4 U' h& s. u1 {) y( }5 [7 }print(dic)
; B$ y' Z, u! O* i27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- `2 b' p' u9 F
4 l1 ^! j2 x( f( Bprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
6 _! n" l& J" t  ?( R8 @  }print(tuple(s))

1 N) ?* W+ {) x" d4 Q- Nb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
- b. q( K- n1 Q) P4 \' @+ fprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 K2 I2 o, a8 Itu = ('Alex', "seven")
li=list(tu)
- }, H# B0 A3 C8 cprint(li)
  n, s. u, Z8 I" O

4 ?) F1 @% z, w+ |+ Cd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) M, H" S- m# E7 c) G6 j
" z, q; X! W# {! kdic={}
$ O4 w7 n  h8 rfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
9 L! p' ?$ T$ N: l, o0 `    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( g/ p1 H# B9 i+ Ma=n.encode('utf-8')   
print(a)
/ z% x( v* M9 m) U; O7 {' b$ N8 r; Xb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
* h9 u" g) I( c4 D: F7 Tprint(a)
# J& @7 U' [3 x1 q5 r) ?b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
3 H/ ^* a/ J! j  e& K4 k  r( rsum=0
for i in range(100) :
% V2 i2 Y* y5 J3 k# ?    sum=sum+count
    count+=1
print(sum)
  ^: p) h* X( I3 K
count=1
- J) ~# x8 h8 e. G" x+ n( Fsum=0
while count<=100 :
: z* G6 G& \8 M6 v* X; ~* b3 V    sum+=count
. ]3 T- q7 O; t- k" D# g+ h    count+=1
$ c( S! I/ a) v* wprint(sum)29、元素分类
3 N0 ]/ I( n& P0 [+ z8 c5 y6 r有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
4 ]& q2 u8 t( ?6 k* K" }将小于 66 的值保存至第二个 key 的值中。
/ q0 \, x7 H0 B" y0 N8 ~1 P即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ p) U0 W! v7 O/ P# eli=[11,22,33,44,55,66,77,88,99,90]
/ ~" E% ^- o: w+ Pdic1={
  T% `1 k5 R. ^6 m, }& |9 ^    'max':[],
    'min':[]
4 Q* ~# f4 O9 t}
; t) u+ ]  V" F9 I9 I( Q6 i) ^for i in li :
9 y' n8 W) B/ q1 d$ E6 C1 Z6 }    if i <66 :
9 S, l: a$ X4 r2 o        dic1['min'].append(i)
) _& z$ i) G0 |, H( k0 l    else:
        dic1['max'].append(i)
; R3 ]$ u! e0 q' @# C1 Xprint(dic1)
- p6 s! n" x" b& e
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}