Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

( ?8 ?/ v5 b9 l, I3 z3、简述 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的关键字命名，

能表明变量的意义

9 Z% A0 w4 W3 z3 U) ]( w  q8、如何查看变量在内存中的地址?
4 S5 f" \' b) u# }3 h! tz=1
print(id(z))
- i) i" j! q) f4 I9 I( L9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
; p5 O$ X& M7 Vname=input('name:').strip()
pwd=input('pwd：').strip()
, }. G4 ^1 o% s: Sif name=='seven' and pwd=='123' :
, |3 ^$ B. B: t" k+ r    print('ok')
else:
2 c. D- \& x9 h( H; |    print('error')

. Y. p: F9 t  r2 k: x* ?  C* l& |b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
4 {# `# g( r; z+ \: y' T& m    pwd = input('pwd：').strip()
+ |* |. Q; }# t+ O& ?! g  C0 N- b
    if name=='seven' and pwd=='123' :
        print('ok')
, Y) U2 d/ D5 j& o    else:
* u) g# H! r8 Y        print('error')
3 R, Q. n' g" s, M) I        count += 1
for循环：
for count in range(3) :
; ]! K' p% \# ?, l/ u! X/ M    name = input('name:').strip()
    pwd = input('pwd：').strip()
4 n! I) |( s. I4 \
    if name=='seven' and pwd=='123' :
        print('ok')
/ z0 f5 y: L7 j' a+ m8 V, p    else:
! f, g9 S) U9 s        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
) t2 K6 E( n" c0 J# \count =1
, a1 G' N8 M0 Y9 @$ P3 Rwhile count<=3 :
$ c& s0 P# g  L    name = input('name: ')
$ ^! ~0 D3 D$ F7 i: E6 o. f+ [# _    pwd = input('pwd: ')
3 m5 x  {. ^8 b4 f' E9 j; Z    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
& K2 o6 |8 K: c* S    else :
2 s2 ]3 D2 a" K9 C( M4 x! n        print('error')
        count+=1
  N2 W/ v3 y$ _6 i5 l, P& O) j  \for循环
: @5 I3 p6 [/ O, @for count in range(3)  :
$ z. Q+ u/ h) X; g# F1 E) H  X    name = input('name: ')
* R  w. ]5 Z" D6 `# h5 {7 \    pwd = input('pwd: ')
  ^% K4 p& R* ^" e    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
0 }0 z* A9 t6 C7 ~3 O3 r        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
& Z: z" h3 F$ @6 j6 G9 I  g3 `: Unum=0
while count<=100 :
    if count % 2 ==0 :
- v9 P' A: d5 ^# k/ Q" {        num=count+num
        count+=1
) i7 ^# _7 ~* J6 ~" R, X; ]0 o" ]    else:
        num=num-count
        count+=1
( ?: [6 ~' v$ ~3 \. |print(num)
1 p4 G9 |  G) E. {
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
' y. Q6 h- v: B; p+ } num=0
count=1
for count in range(100) :
6 s7 C0 K; X, T6 d: H% E    if count % 2 == 0 :
        num=num - count
    else :
* R: u" Q+ s) F' J" x* T; K; x        num=num+count
print(num)

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

, ]7 U% \/ q9 o4 q6 r3 X$ F( Fcount=1
) v( e1 D/ o2 m: @" Xwhile count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
5 O* X; h5 P, a' f* S        print(i)
$ B7 y0 }" X: J
! h, B6 v: `( Lcount=0
$ k. V6 u- G) X4 [4 _: b- d4 ~  jwhile count<100 :
( R( V5 g+ Z3 ~4 }* O5 C    if count %2 != 0 :
        print(count)
9 l7 p, c2 i- ?4 x9 c    count += 1
, S- q0 c& Q7 _8 }! b
- `. a& ]. a  g3 D* ce. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
$ l( S4 J% m" R. o3 g
5 [: o9 l+ ~& C+ S7 _8 z/ bcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
$ g# M8 m$ M& O! f    count+=1
+ m: m' K9 R! n7 z8 k
  @; W% P7 D3 V. Z/ O  n12、分别书写数字 5，10，32，7 的二进制表示

9 }/ s. V1 ]- i' B8 k" p! rprint(bin(5))二进制   0b101
  V" \! G" L/ @: Wprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
( P: `# R' |; S" L& g  q17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

# m. x! c5 F2 _4 t" M, h18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
. e1 O5 C/ T- ?4 B0 N0 La. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
1 W* \0 Q9 g2 \4 O
7 x' W% @6 ~/ s/ k/ Jb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
: {9 s3 k" b/ L4 a/ He. 将 name 变量对应的值根据 “l” 分割，并输出结果。
  j* p+ A! w9 U" iprint(name.split('e'))   ['al', 'x  ']  列表
7 I/ c  G" |1 F- n6 m
g. 将 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'))
4 U) W$ x+ F  j( a21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
6 e: T* [$ f) ^name = "Alex  "
( \3 J$ ~8 M2 \" m" d& l, B7 K/ {for i in range(len(name)) :
* v3 ~) e/ ]; K7 \* B3 Y    print(name)
for 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']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
: B) Y; N& t4 Q. s4 N; u. yprint(li)
['alex', 'eric', 'rain', 'seven']
& a+ K  G6 N. M3 g2 c' z- ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
6 O  A  f; D& ?+ \% E/ fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 i2 ]" H9 a" a4 mprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" \- v2 e* r! @0 ?/ y2 Z/ Fli.pop(1)
* `- v4 [1 T, v# B, x4 @print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
: y  {5 m$ e7 hli.remove('alex')
- e' G4 L3 b  {. Wprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 a8 I2 k$ s6 e/ fprint(li.pop(1))
5 I- ~4 L% l  s0 t7 r* lprint(li)

1 a/ J$ @" h+ Q) k( \eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, \) X) \; r+ ]li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
- U& z0 n/ b4 D7 }    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; |' k; y/ X5 z: [) Ha. 请输出 “Kelly”
* B  C2 w( k8 Q% p1 xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
5 i; r' q( \- Rli[2][2]='ALL'
8 X6 k; p0 X6 lprint(li)
* C) Z. N$ j6 b8 ~24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
0 }8 y, t" u0 T+ A1 \a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
0 U6 Y+ f8 R3 Y# Q2 a5 dprint(len(tu))
6 o% O! y: W! g" r6 @b. 获取元组的第 2 个元素，并输出
: s5 t/ t* o! aprint(tu[1])
  W) g2 j) P  h0 }( D& `$ je. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
) M6 V* c$ L2 r% u6 W    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
. D# W+ A3 N# A5 xfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
0 T( N* E5 I& V9 Y/ P  x- M12 rain
% b: `; }# w1 {9 Q
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
7 \& j* h! N- D1 s% G6 z0 B. T* S(12, 'rain')

4 r: N6 ^' w3 {+ S( l
25、有如下变量，请实现要求的功能
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])
. d% E7 N) ]+ o# qres=tu[1][2]['k2'].append('seven')
/ |4 t& O0 Z0 L# Y2 |6 q+ S" i
9 z% k8 L( h  r7 Uprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 g3 _3 U) F- V- O! y    print(i)b. 请循环输出所有的 value
7 f, s+ ]+ v2 {: D. \; pfor i in dic:
    print(dic)
0 `( q! z6 S* C3 R2 zc. 请循环输出所有的 key 和 valuefor i in dic:
& U, F/ t0 d! o8 a  _! U* c  A: {! Zprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  w/ i( A& J% }) [! D/ Vdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
! o0 p. l; ^8 }2 E( v# c& G6 }print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
2 r2 S+ ?5 |' q6 O
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* K: H( N4 B! `! f/ r" ddic['k3'].insert(0,44)
, N  R6 r2 m& Q2 ]' O: L# }  M7 Bprint(dic)
27、转换
" f  M2 f2 q1 U0 N/ U( F; qa. 将字符串 s = "alex" 转换成列表  s = "alex"

' c1 u( B  l( ~( C5 \5 T# r/ `print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
" f0 n2 h8 g7 H: Z- t
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
' n2 |/ C4 [! B% J6 {/ J8 t' oprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)

( p- C* M. ?8 H9 w7 k7 N/ A! H  o
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
, ~( P1 H1 `5 N# U
  o* Z! N3 a& M. ~! j8 fdic={}
7 m9 x0 N6 p0 F7 y/ R5 y4 h7 P+ F6 Hfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
8 t% g4 W7 S. I$ [) |: Q. v4 `    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
6 P5 D  \, f% N- x) x( ]: Y  `sum=0
7 P# x2 @5 ~# j; L" q  f" Lfor i in range(100) :
; M1 z3 g& Q! F" O+ I7 a0 z3 j2 b' F    sum=sum+count
    count+=1
3 }& u+ N5 q7 c: F% dprint(sum)

; N0 t# v3 ^3 ?; t* c' kcount=1
sum=0
while count<=100 :
+ J# U/ C( L# \3 U' d    sum+=count
- j8 g' c. w0 m' _* j    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
8 W- N) |) ^( v4 d( A将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
4 Q6 t" b& K& |8 j    'min':[]
4 |% E. b1 }3 a- i" L$ o}
for i in li :
    if i <66 :
        dic1['min'].append(i)
7 M) r" ^/ ]0 W    else:
5 z0 e5 L9 i( E! I8 U5 V        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( a3 n- p/ ^7 Y! v& o