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

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
, A0 |2 ~  N- G7 F: T8 @z=1
print(id(z))
5 \& L% f; a; C2 ^% ~, B9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
# P9 \" Q9 n' E0 Bname=input('name:').strip()
pwd=input('pwd：').strip()
5 W" a3 Q' T: t7 D* h$ M0 {3 Gif name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')

& Q$ o! v7 j6 n1 Yb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
$ `5 M" m2 x8 m/ x' ~% {# C! V    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
& X3 O! n0 n) _* d6 k( x! p; o    else:
2 g* L9 v: l4 \  w8 u& d$ t        print('error')
        count += 1
, w5 d1 C* s% N3 ]: j- O4 w) Rfor循环：
for count in range(3) :
4 v/ F( Q' W" A+ P; R    name = input('name:').strip()
/ Z/ o" y8 X$ s( \5 L, ~    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
: u4 R1 N1 a# Y' z5 W    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
8 K! A& L. B3 ]: zwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
5 `9 T3 a5 e! }2 T9 B: W; \    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
7 v% M1 z2 H) O4 v& F8 A2 T9 ]    else :
6 @# i; j( v& F' I) w        print('error')
- N3 Z# E6 L6 ~2 F3 b        count+=1
( X3 C% A6 o; Kfor循环
for count in range(3)  :
    name = input('name: ')
9 J. @9 S: e) e. _& R    pwd = input('pwd: ')
5 X, z7 c: s5 f    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
1 y1 I9 X' b4 X% a        count+=111、写代码
- C; U: x4 M+ a# `1 }' Z/ P5 ua. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
5 L# R1 b+ W! |6 k4 y3 D" A: [num=0
  z' O: k+ p/ A' i5 Mwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
$ W/ A9 n! U! w( D( v    else:
( O4 c  W9 H' ]# @& H        num=num-count
        count+=1
print(num)
) i' ^% n( i0 {/ D4 \  l7 [, b- b* i
% v9 i/ }( X$ z$ sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
5 i! d. E" I$ X% O: p& | num=0
$ ^0 P$ N- D, K" Y2 lcount=1
" k9 c7 B9 b7 J8 D  z% s, t, a, ffor count in range(100) :
    if count % 2 == 0 :
        num=num - count
( d/ C. {9 l% a/ N& _* t    else :
        num=num+count
print(num)

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

- Z$ }- }7 t) Ocount=1
5 r& e) G3 l0 X' y, R7 Mwhile count < 13 :
    if count !=6 :
" e' Z. p5 R0 \$ H/ @0 o        if count !=10 :
9 N" `: k( j" _/ G( O& Z            print(count)
$ L% Q( J% i7 {% @( S! \
9 w1 {2 K. n& o$ G$ }    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
& R: [8 k, f$ }4 ?for i in range(101) :
1 u5 L3 q8 q% j5 b    if i %2 != 0 :
        print(i)

count=0
# K1 X3 V4 J: N2 N% B6 p. y' Nwhile count<100 :
  C- A  F) i6 A9 I    if count %2 != 0 :
" K( O  K) A, _) `+ P; y        print(count)
    count += 1
" p5 Y( M/ I6 \& R- ~
e. 使用 while 循环实现输出 1-100 内的所有偶数
) q+ ]8 N9 b, l7 K: V9 ]5 x/ afor i in range(100) :
    if i %2 == 0:
& Q/ i& V, D( F0 B, r  `) P4 I3 U        print(i)

count=0
# s; \9 [/ n4 E7 Owhile count<100 :
  ~$ F/ Z. @+ t* S0 w    if count%2 == 0 :
        print(count)
* v1 y- r. `3 Q/ [6 Z    count+=1
. i  I% e' c* g1 O
6 C8 n1 a6 k# {& g12、分别书写数字 5，10，32，7 的二进制表示
' M; y) j7 q  e. c0 Z8 Z
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
9 g! v1 {4 `8 M+ Zprint(oct(5))  八进制  0o5
  g/ v$ o- L7 }  ]3 D" X+ i3 N14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

4 c) d3 q6 W6 z) [16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

$ P* q" }% u" f0 M( T/ r
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
0 X3 [, z* I& B. R5 x3 _
2 b& u' R8 W" d- b. Lb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
1 h# I) k& q0 \& q) D" qprint(name.startswith('al'))
! K4 K/ {3 r* `c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
3 K$ k, C  T) v, ~' V% od. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
, d+ R3 ~* o$ Pe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
0 Z. i0 b4 X0 E9 }& N* A8 aprint(name.split('e'))   ['al', 'x  ']  列表
' r- V7 Y& }" q% d
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'))
& U/ Y4 p$ g& j/ p" m  I21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
  Q0 x0 i! `* k- n# N5 _& d0 L9 Cfor 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')      
- y" k/ q, ?# Z" {4 S: D2 U- |8 Q' [print(li)
$ x2 y8 y- h1 T5 H8 u ['alex', 'eric', 'rain', 'seven']
" t+ e2 z% ^0 yc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
' ^' O+ g$ }. q" qprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# ~& K& O, Z3 ]; [7 A  g7 u+ Q' Dprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
! B' W4 E: k- yli.pop(1)
# d( g$ [$ n* `. i% tprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
$ Y0 F1 F+ C" t% n. ?f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
* r; u: k. [- P. w$ F' i' d' J3 Rprint(li.pop(1))
3 O- {- W2 ?& N' F# j9 Bprint(li)

' q# _1 m* {& G1 c6 m7 Jeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 X( w7 {& [: V! jdel li[1:]
, q6 l' K" d. \/ Cprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
' D: ~+ x* O$ L. ?8 W, cli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
2 u) q; k1 i" c    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 D0 S+ o5 T" N( b4 m4 ^a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
. ?0 A# k+ }/ v, g' v& `0 Ib. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: e$ a9 {/ \( C5 p3 I# W3 sli[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
( Q* d, o6 G/ a4 x2 R! I7 i. ?+ g+ Gprint(len(tu))
b. 获取元组的第 2 个元素，并输出
) F* K9 ?' }3 M$ u1 R! f& T$ Gprint(tu[1])
. x- L# k) d' f3 l1 a/ |1 }e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
6 R  U4 Z! a3 ~    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
+ U! f/ R9 t! l3 X    print(k,v)
10 alex
0 p3 K, g2 s* z' m( d11 eric
12 rain
6 ^5 O( F- U* ]1 Q$ ~3 P
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
6 p! M% n* b: F(11, 'eric')
(12, 'rain')

/ _0 M/ M* Z& M# B4 R4 S' S) L
+ {3 d1 i4 N% j4 k/ a7 B25、有如下变量，请实现要求的功能
& Y( ]& H3 f9 U0 ^: Z  l9 D  \% Dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

, ^! k4 X1 ^) H5 A$ s0 M, c6 H, Xd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
/ G5 a; p% x5 _4 n0 Ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
6 a' o# K: `/ A+ H9 h26、字典
" {. O4 m. U0 |; l- N/ Zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* C* z5 ~( _- c* _3 i$ _/ U9 \    print(i)b. 请循环输出所有的 value
. M. @. c& {  i( ]$ p3 ], tfor i in dic:
    print(dic)
. Q, F8 o0 @) T3 Fc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
- ^5 M6 y- \" }( ~- u/ sd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
! T' n8 k5 b9 J8 d$ X4 W) g2 Gprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
, C7 a1 f# [7 E# fdic['k1']='alex'
1 x" V7 A% w7 nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
8 F+ J0 G% @% Lprint(dic)
# a& U0 B! J  Q" J
8 a8 a+ G+ J# e% o9 W# rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 S- J' t9 P" }- V/ I& f. [& W8 a- edic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 d/ B8 y  M+ r' c9 Q( V
print(list(s))b. 将字符串 s = "alex" 转换成元祖
( {0 z6 H, j0 {s = "alex"
print(tuple(s))
# ~- J4 x. `& Y6 b
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
& X' U6 r" {1 [* t5 _$ \# nprint(li)

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

dic={}
$ F) f7 ~: b' n6 e; ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
9 K. O/ M, _0 I0 z1 r( ?a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
- g$ ^& h1 W' T# J- N" Uprint(a)
1 t( t* A. I+ Mb=a.decode('utf-8')
2 s4 S$ I; C8 @print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
9 ]) r# G8 P9 }! l* ?b=a.decode('gbk')
+ p: {* p- L! t9 R# Rprint(b)28、求 1-100 内的所有数的和
* |8 N; T& a3 x* [3 J$ `, mcount=1
( T" e# [' l/ w6 y3 J4 {sum=0
/ M( L) Q+ S8 @: a' `5 A5 m0 jfor i in range(100) :
8 m1 m  |# q) Z2 K* `    sum=sum+count
    count+=1
3 k7 `8 t8 f8 _  g6 ?) eprint(sum)

count=1
sum=0
0 w) C' @7 Q5 C7 I# y7 ^while count<=100 :
( R! Z/ F" O8 J4 V, K, t) K    sum+=count
    count+=1
- ?1 F2 U; w& Z6 Iprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& ^: {" X  ?3 t5 W& x0 Y) q& F将小于 66 的值保存至第二个 key 的值中。
9 a& z9 X9 Q  L9 o- o3 s即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
$ C8 y' H; t( r+ @- |% @: P, odic1={
    'max':[],
% y. S6 ~6 c7 @  t0 w    'min':[]
: }7 @! k# o( t6 p}
; `1 u7 A4 u$ @( xfor i in li :
    if i <66 :
7 s0 H! ?8 p" d- O4 x* \) E        dic1['min'].append(i)
    else:
5 y" O4 @9 Z/ }1 [        dic1['max'].append(i)
$ g) r1 X0 A6 ]print(dic1)

0 f7 L1 C0 t! O---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
% h8 c+ s: M& z; K. A7 P9 l