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

. z$ n/ R5 q/ @2 f! y: |9 s5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

  e' w1 R' C- t0 U( D" k6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

" u8 I4 }' S7 a# Y8、如何查看变量在内存中的地址?
z=1
print(id(z))
9 f* N% ?7 b2 b: b, |5 q  e9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
& x. ^- H# D. u5 x4 ^8 N7 L* x! Mname=input('name:').strip()
, n7 Z& r% T8 Qpwd=input('pwd：').strip()
0 g6 k& L0 n2 d3 n" K# `if name=='seven' and pwd=='123' :
    print('ok')
1 K; U4 O5 Y9 @, ?% Zelse:
    print('error')
! S" l; O8 c% p
6 l" C1 Y1 ~4 N8 C; {& q! ?, [b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
/ }0 h& J+ h  Fcount=1
0 R, E0 v  c: |# ?. H# h/ u6 Twhile count<=3 :
    name = input('name:').strip()
. d, E6 u2 I3 |9 B0 g) I3 W    pwd = input('pwd：').strip()

+ L% \$ Y6 b8 q( n, l3 {; M    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
4 {9 y2 g( ^+ T9 S. ~5 H/ Y& b$ d$ v        count += 1
" P: `* o& e  W7 p" M$ Lfor循环：
- K1 P  T3 V: y& U, k4 V; Afor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

! `3 V- I$ [7 L4 {  T$ G    if name=='seven' and pwd=='123' :
) F0 f# s: e; Q6 g3 ?7 D1 a        print('ok')
' w2 S$ m3 w6 R4 e- b' [- V$ X' {* \  H/ b    else:
% X4 j6 L. S! Z# D3 H        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
1 ^$ a5 \8 S2 W" Uwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 R4 \" f6 @, b! P; }# V        print('ok')
' z) P7 Z$ N6 f0 U9 F* j    else :
        print('error')
        count+=1
- N  p' G# l  wfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
; ~7 z, x4 g! o- \4 C    else :
        print('error')
        count+=111、写代码
/ g' O  h1 Z; Q  \, ^a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
% t1 R0 e9 @% Z% h7 ?num=0
while count<=100 :
) y" y% L3 B1 I* \: P  }" ^* D    if count % 2 ==0 :
  i: o* I* n8 ~, V2 q7 H        num=count+num
7 L8 H. r0 h0 a: m( q% m        count+=1
    else:
        num=num-count
        count+=1
3 L3 g( J: [! r9 ^5 b, f; x; sprint(num)
9 U, I  K& z4 w2 t; t3 W7 B# z% H, V
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
; }! Z* u0 X+ X* c& p4 t num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
( h. P+ ]! c: ~3 Q1 ?: R# v& k+ n        num=num - count
8 D# I: f, p& S    else :
        num=num+count
6 M1 @0 Q% [3 ]% d5 B4 Z1 Cprint(num)

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

count=1
6 |) l2 C5 A+ z/ |) W2 m6 awhile count < 13 :
    if count !=6 :
* n% _1 U$ c+ N) |0 N( T% P) q        if count !=10 :
3 H7 \" E9 F) }' L+ Q  v            print(count)
3 O5 D' S2 {9 D; h
% u$ O4 y- _9 q" S, P$ }# ^7 U$ b    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
" j) B9 {5 V2 qfor i in range(101) :
    if i %2 != 0 :
, d6 D& k; n; Y& ^6 y        print(i)
; `5 L0 `& t* {) p6 W; Z
count=0
while count<100 :
( H' n) C, b, V. K+ G/ m    if count %2 != 0 :
        print(count)
    count += 1
2 {: Z0 O0 `5 }/ P1 I
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
: `( m" {: O/ C; D! H    if i %2 == 0:
        print(i)

5 Z& B# e. G0 F6 z( rcount=0
while count<100 :
* f. ~9 Y8 s) ~; E( t% n    if count%2 == 0 :
        print(count)
; o' J* ?) F0 X+ }  z  ]    count+=1

9 Q- ?- V: _1 X12、分别书写数字 5，10，32，7 的二进制表示

0 A( q- y! H  C% Y. J3 lprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

9 s- S/ V) z' b- p+ h16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

0 E) w8 a) o: u; {0 J
18、布尔值分别有什么?

False .Ture ,或1  和0

% T! ]8 d/ j6 l5 q! r20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

( q3 F: z7 F0 Y, zb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
' w* e6 j% x. N" d7 pc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
  p3 [/ n- ?6 g8 e, R' U/ n( i1 Pe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

! g" q8 f$ X+ s2 ?. M5 ]% Pg. 将 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'))
" m  m' }( l* E' K. L/ L21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
2 H: V0 Z& m2 y! ~3 C    print(name)
& i5 ]4 b/ X" D/ ifor 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')      
8 e' H6 k0 Y9 cprint(li)
['alex', 'eric', 'rain', 'seven']
- z/ X9 O- L% Hc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
+ g% E$ k7 N* v  v  Dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
( p9 [: D1 J' n4 o5 jli.pop(1)
print(li)    ['alex', 'rain']
% G2 A( g9 p7 e. _( T指名道姓的删除li = ['alex', 'eric', 'rain']
3 E' q) S) b  n5 rli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
9 Z8 ]  o% ~1 {2 @8 X7 `. _/ l; |# t; lprint(li)
/ V( b4 j" R( d$ c
eric
9 S: H0 V7 m0 R. E['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# @0 s, w. ?0 a) _del li[1:]
' j$ T$ \7 N6 c* e' n! D7 f3 Yprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
& ^( e7 a; m! R3 x    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& ~' f* l1 Z  V6 N, pprint(li[2][1][1])
% U/ A4 y7 F. G  q1 Ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”
5 t+ E0 q- [) Y$ c: u2 n; tli[2][2]='ALL'
5 L  s0 |4 y' y  F! C- @, h# [# yprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 i! B- ]- ^0 q8 y# c! {- @for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
* u9 ^& @5 Q. ~# i" u2 ]0 y11 eric
12 rain

0 c! A. p: \+ Y! j" Afor k in enumerate(tu,10) :
    print(k)
(10, 'alex')
4 ]/ x2 ^8 c9 {(11, 'eric')
1 N! @6 k( F7 C' U- X' H2 {, }(12, 'rain')

% K3 }. f' L/ F' p% w7 y2 J+ S' h
25、有如下变量，请实现要求的功能
  C7 g* ?$ F2 a: Ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

1 X) V  }6 ?* r5 u8 l8 Z9 ?' Y: ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
5 y! b/ r0 v. y& v& ~tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
9 L7 K: }8 k3 {0 k
print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
# T( [( m% }9 X5 B) ]' a: Yfor i in dic:
1 N9 v5 ]3 p3 f( F/ c+ d: P3 G# |    print(dic)
4 E4 I2 i, l- ]% X2 T! @c. 请循环输出所有的 key 和 valuefor i in dic:
3 I# D4 g; P' vprint(i,dic)
8 d) i5 N+ k$ _( Pd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
! I# f. K, s. zdic['k4']='v4'
( G1 t9 w, _: C: T1 S: a) Q& Eprint(dic)
1 F' U# Q/ u* R& [8 T) c9 ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
$ Z: b$ |2 L& [9 X7 X, s  h- L& zdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
9 |3 W$ ~. a( _7 _dic['k3'].append(44)
print(dic)

  q$ e& Z) r+ }/ J# cg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
$ m( U+ Z2 n! ?# C+ Va. 将字符串 s = "alex" 转换成列表  s = "alex"
& Q  P1 d5 o) B. V3 V# f9 c& }
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
: y3 `# e9 _/ |9 E8 N8 L
; D' Y3 y( b; }' c) Xb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 W' X( t' w' {$ r1 Ctu = ('Alex', "seven")
( H9 w) B/ E& h4 Z+ s6 Vli=list(tu)
. c: Z! [, j) Q4 ], h* dprint(li)

4 P* }5 F( c5 C+ I
2 Y' E( A1 [! y8 k' a7 Jd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& m9 Z6 Z0 x+ o% Y, r
3 {/ ^) |/ T; C( h! C: f. x7 ~dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) G3 G/ c: i8 D% |    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; }" e: q2 J2 Wa=n.encode('utf-8')   
. l& N* P' _% n7 m, t% Y% b, Mprint(a)
# q- t  k8 Q6 n* fb=a.decode('utf-8')
print(b)
8 s; r# ~2 v/ e) C2 Hb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
& K/ n1 l; t  A& b! @1 }$ kb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
/ B3 |' {; t1 K- X) }+ k9 l2 ucount=1
  [& z. {0 f. ?% o; L3 s# Xsum=0
: `1 z1 u) W2 ofor i in range(100) :
    sum=sum+count
0 p8 R  r6 ^5 o/ E# U    count+=1
print(sum)

count=1
sum=0
while count<=100 :
    sum+=count
    count+=1
: G+ m6 q% ~8 p2 ^, Xprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ w- U% d$ ]  Vli=[11,22,33,44,55,66,77,88,99,90]
dic1={
: X* D2 |: P0 |. q$ w" w( f    'max':[],
    'min':[]
}
  s2 c: X  N) T* M3 j/ K. Nfor i in li :
$ t( _% F: A7 {- _; a1 I1 y; ~    if i <66 :
        dic1['min'].append(i)
0 }+ t! s& O  \0 c7 ]) U    else:
        dic1['max'].append(i)
( e% o! W  t' y( tprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}