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

8 T9 m. z" c, U# ~- W- U* [5 t" a4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

7 i  N) ]3 f+ R! H) Y' O5 b8、如何查看变量在内存中的地址?
; l1 X4 C2 D: D8 W- M4 Z, E  D  P/ B" jz=1
print(id(z))
' J; k9 \( m7 y, X9 O3 ]9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

6 G' L+ i2 \; M4 Y& q10、写代码
$ R" Q; Q, @* na.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
) m. w" N/ u- Z: Z  k    print('ok')
4 d1 v; y! x$ H( d* J# I6 W4 r! aelse:
    print('error')
1 h. K0 L4 \* t  @
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
* I( `- w. V  t; v2 J: L" Kcount=1
5 F. H% X% e8 L5 Iwhile count<=3 :
) \! K/ |# _" w% a8 o    name = input('name:').strip()
9 \9 g7 U4 r& Z; t, s! U9 N    pwd = input('pwd：').strip()

% x$ `% j- ^+ b! b4 q( q    if name=='seven' and pwd=='123' :
        print('ok')
* _; F8 o7 ?$ i5 B  r    else:
+ i. y! ]6 |& P        print('error')
        count += 1
for循环：
for count in range(3) :
& `, W, y1 m& ~: s9 {2 K3 H    name = input('name:').strip()
) H; p* ^# [* m/ z  X0 X    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
% T; {& T4 O* A) h/ g7 a& {) I        print('ok')
/ d: G5 s& q* q) o) p- {    else:
- ?8 Y; {: l. ?5 Q- ^        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
* ?  e1 C! i) H8 i    pwd = input('pwd: ')
* J4 I; v' ?# w' H) R% p    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=1
* f( W: |% y; D; Ufor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
" ?; w! V  s. i, O' Q  c0 K6 l    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
& I: e& K' O, s2 |% x    else :
/ z) Y" b/ T, d6 s# N' w        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
' D2 l: v$ G$ tcount=2
2 x% C' T5 k' f( O4 ^$ {) snum=0
while count<=100 :
9 H9 k, }4 u  {. W4 Z    if count % 2 ==0 :
# J6 o  K2 b& T* ~( U        num=count+num
8 s$ |9 X7 L9 j& [. c        count+=1
    else:
) w3 `2 x( ~6 n/ R) q        num=num-count
        count+=1
9 j  D7 h) h, u- D, dprint(num)
& ]. G7 A# V6 C! f4 w4 W
5 B/ N5 R+ j; y. b$ Pb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
4 y+ u8 \! v1 l+ W. Pfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
, c! H2 M; q0 W% o5 P        num=num+count
, a6 [) {4 f& sprint(num)

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

$ u( H5 y) B6 ]: n8 Q3 R0 \count=1
% a% \2 o7 ^/ Uwhile count < 13 :
* h2 e* r7 V0 b9 q7 u( V5 g    if count !=6 :
7 g! K+ f. n8 z7 ^) o        if count !=10 :
  f: d2 j4 c* g* P7 ]# t# W6 t7 }            print(count)

9 J9 t+ M' V1 J& C+ r- x. ~/ o2 m    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
: i. z- a4 T2 i* Dfor i in range(101) :
( ^/ L# A4 g0 b- a4 X    if i %2 != 0 :
# ?! {8 [1 N' z1 \) ?2 z, @        print(i)

9 K& o8 M) O/ x% O; ncount=0
# r; g/ v" {/ e" q- z) c8 Z/ S, kwhile count<100 :
" N, A: |7 x* \5 d. C  w    if count %2 != 0 :
- z0 x! t# n* i        print(count)
    count += 1

+ E0 W: A% e% p9 S, w# J0 I- e- J! oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
2 ?: S. e, q% r5 ]- \0 k. i    if i %2 == 0:
+ e& g6 f8 s7 W- S        print(i)

- M) t4 l, |$ e; `2 wcount=0
! V% s6 A( r) O. }; jwhile count<100 :
    if count%2 == 0 :
        print(count)
9 H- X. Y7 K) }' `- y1 g9 o: m* C+ P    count+=1
, H/ t% d5 R1 c2 R- W
- M: |: M8 p! |3 |5 c- Z12、分别书写数字 5，10，32，7 的二进制表示
# Z; T* K1 n! ?: ^9 P, G( P
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
# C; u! r: R- \print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
& v7 }+ I7 \  r, x. Z# j9 [17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
3 e1 U  g- K- z' ~  tprint(int.bit_length(n1))  结果  3

$ {( l/ m% c  z  _
18、布尔值分别有什么?

False .Ture ,或1  和0

- |% C" w9 P' S  o% n+ y; v, d5 O) _' p20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
& J6 y" u0 T. j
- e$ V/ G. z! X: k- v7 Q5 p- @: Jb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
# u/ L" R' a9 W+ \* B* l  J" Gprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
2 w+ ~1 s1 F- \4 gprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
+ z  f& C8 Y" `4 u5 z" Jprint(name.split('e'))   ['al', 'x  ']  列表
* B5 V0 ]0 N0 E1 B/ r+ P
! K: A/ G: C# W, E% {g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
, _/ e! R2 ^# j
- V! p# s3 S6 T: |& @5 ^+ qj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
, n& g8 y$ B$ o9 z# Y, F依赖索引
name = "Alex  "
- [% N% ~8 I7 t7 Dfor i in range(len(name)) :
    print(name)
& a. M$ f3 h9 m6 Hfor i in name:
+ |# \/ d( t( c    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
- O, a7 @& R% _& {* `" X3 B22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
* s2 ^2 }$ b% P. [5 F2 n3 w  f! m3 eprint(li)
! |6 c: l2 }' X% C9 p1 C; f ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
+ L; |3 u$ Q, u) R5 I* Wprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
% F  h, e& B7 h4 Q4 t( [* J4 j. @( g% o指名道姓的删除li = ['alex', 'eric', 'rain']
' m- f7 H( ?' ~. P; W6 ^li.remove('alex')
print(li)
* O6 U0 W: L) x# C  S0 y4 zf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
6 A4 ~. _' S! c% Qprint(li)

8 X/ D# I& ?: g9 x" s# |7 U  ]eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# S+ ]: e  F4 U! Q3 h5 Y  M5 Idel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
5 h4 y1 a5 @4 ^& a6 efor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
& ?/ Y8 h, Y0 H3 Zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 c9 ?0 ]$ E( w+ _* [print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
! _" O: m& P% ~9 [li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, t) U! L9 y) z. k) @: J- W8 Rprint(len(tu))
b. 获取元组的第 2 个元素，并输出
4 a9 w4 l9 p! ~- m. D9 bprint(tu[1])
$ a/ N2 P) O+ d' qe. 请使用 for、len、range 输出元组的索引
. Q8 N; l  x% j" l0 R4 h/ b6 Y: ffor i in range(len(tu)) :
% Q! y7 a  o  T% R* U    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
4 n) M0 H3 Q1 r+ S; a* U8 s" d" b5 u    print(k,v)
10 alex
; v% V" E: x9 _8 s5 v/ f6 b3 r11 eric
7 d% q! p* h8 [! H% R: _6 I1 j* E1 W$ b12 rain
9 O" Y3 J6 [( S2 `! J4 Z
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
" X. F3 b8 D+ u(11, 'eric')
, L! I6 ?& S' L' |7 N* a& ^(12, 'rain')

3 H4 ]" O# t2 H0 I: ~( L
25、有如下变量，请实现要求的功能
+ y; O3 C. N( s' `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])
res=tu[1][2]['k2'].append('seven')
5 n$ T2 z$ [+ Z2 m9 W/ C
0 O2 l  {) B9 N/ M  G: Zprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
. n' a5 Z2 [. J+ v  ^' k2 gfor i in dic:
$ G! v8 z5 A. E1 w6 v. u' b. E    print(dic)
7 _2 p& ?8 w& d* h. O/ p: M/ Qc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
" v& J8 {8 {% y4 A6 }d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
5 w) O" F3 }1 X* _  D  g" Mprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
+ O5 J  Q( q4 f. f' u7 o# A+ h2 gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
+ D$ U& Q4 X% }) Q) i
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( `0 P/ g5 p5 p" C0 F; i2 }dic['k3'].insert(0,44)
print(dic)
& l' Q! w- G. G' {( a1 s& P27、转换
8 ?: f% b4 i1 Q' @$ S( ya. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
+ v) e/ y' u/ M5 D3 R0 N' zprint(tuple(s))
6 q8 u* G- o* U* d/ p- G' W( @
: h# v7 }" n* vb. 将列表 li = ["alex", "seven"] 转换成元组
) e8 Y; S9 X. |li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
9 f, Y, }' E3 J, zli=list(tu)
print(li)

* O, h' k6 R" Q2 M% \
( C, Q% J6 i, f! Rd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
! D4 z: {9 g6 s8 ~6 L% afor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
0 c( o, X3 x; X3 M, @9 \6 O    dic[k]=v
. Q4 F: {1 {7 X8 z    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)
) g5 ~' K, k/ p9 [b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
2 [& l' g7 M9 k  O: Rcount=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
1 A$ o9 {; }  }4 U+ Jprint(sum)

5 E( B# g, ]! Kcount=1
' W: G+ Y( A- w4 p- x9 ~9 Qsum=0
while count<=100 :
    sum+=count
- t+ |2 f0 R4 Z$ ], c  m    count+=1
$ \( Y( x' Y* [- \( a& E( Yprint(sum)29、元素分类
* C" P" C) K3 a+ @! M" l5 \有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
9 z1 K/ n* Q- `. y) g3 g- R" P即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
( s8 ~7 x/ t; `) _1 ^- C; K    'min':[]
& [! |3 P: ~0 E5 _7 y}
for i in li :
, N8 d5 v& {9 B    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
. D( g! [/ _# t/ z: N, c- Eprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) j: B0 ?! o$ T: L1 Z# u