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

0 V/ o" d( s- B, `8 l- [9 H& G4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
4 u- U0 J% _" }5 e2 T9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

4 ?. B' L! c9 a0 s* Q10、写代码
- S4 ~- _) r4 E% P! ?a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
- t% s* F% C* V, h* v3 Cname=input('name:').strip()
8 j8 F5 P: Z- [* \pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
, e0 g1 {* W, h0 [0 M    print('ok')
( y8 W, s5 t! }% Felse:
    print('error')
9 E7 C0 s! X0 f9 h; O, l) D+ c# h' E
* |) b6 ^3 u" wb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
, `; n% o9 E" Z6 J5 @    name = input('name:').strip()
    pwd = input('pwd：').strip()

  x! ]  f$ j% r+ }9 O    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
5 U7 o1 e- ~1 \2 Q( T+ Gfor循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
$ C' v, ]+ L3 ?4 u8 O/ y
    if name=='seven' and pwd=='123' :
' a8 v# q1 M5 t. q+ v6 E4 C# O        print('ok')
0 m! w; d" \/ l. w) o) f: n    else:
6 C# ?2 L4 Y/ ]( z7 [5 P  a        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
/ R9 m, Y1 [0 qcount =1
while count<=3 :
- H- r" p9 \* V& ~    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
4 e4 U" g$ }  F6 d) o5 c        print('ok')
5 a- S# S" l, Y4 [# W* i! P, J7 U    else :
4 |( |, w4 \; l# c% G        print('error')
/ f# O" r7 {2 r/ M) Q        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
" ?' d: C3 K1 E! ~4 E    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
# K! M  I) J% W: n        print('error')
        count+=111、写代码
- C& q' F: p* Y9 O% A% b; Ja. 使用while循环实现输出2-3+4-5+6...+100 的和
) @5 o1 U2 \, w1 s. s4 K# xcount=2
num=0
! A3 m  E) x) f- G0 \0 Ywhile count<=100 :
; O8 V1 E7 [1 G8 M9 ]    if count % 2 ==0 :
+ p. j6 `% Q2 d4 C        num=count+num
* \3 P8 M2 Q- j( b        count+=1
    else:
  a+ f9 s) v. ~  ~3 E1 j        num=num-count
        count+=1
print(num)
7 @' p: q9 N% V% j. T8 T
( l8 l) N* a  _2 s& Y& w" T! a! Bb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
0 a- i* B' V7 F4 U9 R" s! x  J$ ucount=1
for count in range(100) :
. q8 f0 I6 O$ B6 a5 ^5 F% Y: Q& V    if count % 2 == 0 :
        num=num - count
    else :
% u1 V& R( X* E' z, C+ F* |        num=num+count
print(num)

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

count=1
2 o2 h' u1 \; A* N: l# f) uwhile count < 13 :
    if count !=6 :
1 K; A, ^7 e6 m, ~/ U( k% ^6 c        if count !=10 :
/ m) f. x  q% J: E8 H3 z            print(count)
$ M, y  [$ G% g& V
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
; J; W5 y2 s* O( gfor i in range(101) :
    if i %2 != 0 :
- H, _  v! L( t* M, h        print(i)
) N+ I9 p7 [/ M5 M3 s3 G
3 U3 u; b6 `. |- t& ~3 }1 t* jcount=0
while count<100 :
    if count %2 != 0 :
        print(count)
    count += 1

1 q- y8 _% I3 ?5 v% w' Q8 Ce. 使用 while 循环实现输出 1-100 内的所有偶数
+ z: {. i0 G2 _, f; ~1 Afor i in range(100) :
; V2 G! S# ?$ b+ [% B    if i %2 == 0:
3 @6 P+ D9 A2 E; g6 q        print(i)

" E! `2 g5 ~, O5 Lcount=0
0 s. D+ C0 L) x* m, [while count<100 :
4 m; i, j2 p* H% L+ h    if count%2 == 0 :
- O+ ^' H3 g$ T4 }, d        print(count)
    count+=1
+ r4 @. q% F3 \! _& F$ S
12、分别书写数字 5，10，32，7 的二进制表示
% C# N& B7 ]- ^8 ?, g3 m
; l  e2 J/ Y. eprint(bin(5))二进制   0b101
7 U, X4 ]0 \1 v) E- Cprint(hex(10))十六进制  0x5
' `8 `4 e" K* F: v5 yprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
: B  B8 y  D. o4 ?( H. @! ]print(int.bit_length(n1))  结果  3

+ Z/ l9 I! p# |0 v5 Z
18、布尔值分别有什么?

False .Ture ,或1  和0

/ s3 k; j; W0 Y4 k. d- P* z20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
; L2 C! b% p" r9 X( y! f5 ^c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, [- p- r* a( f4 q. c. K+ yd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
( t/ n- c, V: c9 a" Wprint(name.replace('l','p'))   apex  
5 V* F$ e2 b+ b, C( oe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

$ h# W: y& ~3 ig. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
* Z! w; }( q4 W  k* ^
: v* L8 U! k2 cj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
$ D- v- w% [" }/ j4 H. D7 }依赖索引
name = "Alex  "
* {- l7 z. Y: D# Zfor i in range(len(name)) :
    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']
2 Q8 u& A3 r9 O3 h; ~$ k# fprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
+ K5 g1 d8 @1 ~! Jprint(li)
" j/ ]0 L0 c( K& r1 @e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
: m3 {1 B( [; ^( g+ Bprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
) k) H" w  `6 P( x- b! ~li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
. O! y9 ~0 U9 W8 x) n. cprint(li.pop(1))
; C4 i; Y! b1 ^4 v- Yprint(li)
8 r& S* B$ X, f& j& _5 s, u
2 s' {$ M( @2 w4 s3 \eric
$ \% r% H+ t* Q+ x+ Q['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
- R" z5 k( d7 |print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 P9 j( J' _; E. E& G/ [. t! Pli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 e8 ]4 U( M( u+ B$ h, O3 ha. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 |2 E& i- g3 Y" ^$ D0 l2 bprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- n  O# h3 l6 l( _9 Z; h; n: W) eli[2][2]='ALL'
) _+ \7 X! @  Pprint(li)
" C: A. ^3 w4 |0 [+ X24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- _, m" j+ r% c- |a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
* _7 Z; `; |3 S& {$ j8 J  g( W& db. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
" m% }8 Z( r# W. ^% e9 tfor k,v in enumerate(tu,10) :
7 f6 u8 ^7 |, v1 y    print(k,v)
6 f9 C0 {' `- r+ `! I- k$ h9 ~6 v10 alex
11 eric
12 rain
1 C( A1 M+ Q4 t4 q+ J
+ t( C2 q  }! O, Z/ G4 [for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
; t4 M  W! h. x! O# C(12, 'rain')


25、有如下变量，请实现要求的功能
" _! _1 x, b9 ~% B$ U" Ftu = ("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')

& @( x- u# L" m/ Hprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
, O( x! G* P  N- w; A: t% D    print(i)b. 请循环输出所有的 value
9 \/ x/ l$ g' m9 sfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
. c, w6 c, `$ a: {; I+ Z+ Pdic['k4']='v4'
, w' s3 ^; L5 w' R9 \. z$ Yprint(dic)
# U6 F4 @6 f4 z0 o, z6 ge. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 v4 d7 {: Y" bdic['k1']='alex'
; y% h) _! X: O9 J3 q4 S3 _print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
- ~; \% H7 t+ t4 {0 adic['k3'].append(44)
print(dic)

3 p, a" p4 F2 [1 S; ~5 V* cg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
1 E( r8 g1 l) r& _* Y9 O& \27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
! K$ j/ q" U8 [3 f! Y- gprint(tuple(s))
& Z0 c9 \& k8 R$ X1 ^
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 }. h. U; x# m  x5 W/ L5 qtu = ('Alex', "seven")
+ U+ k6 o# f* @$ M0 Eli=list(tu)
- p! F: ^* @3 n) Z4 G5 Eprint(li)
1 |( Q1 o! b( V  y' i# G" q

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

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
* P3 _# x' i9 \3 e1 Dprint(a)
6 p  T4 w5 F& k( Fb=a.decode('utf-8')
( b4 O; n% G: u9 {6 _9 U2 [1 tprint(b)
$ o2 R2 _$ ^: ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
8 M& r( o. D+ i: J* u5 D. j% N1 oprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
: r  q. l2 V5 r2 a% @  F9 Pfor i in range(100) :
4 h' Y! t8 s  R4 n( T    sum=sum+count
, p/ b; S( K+ b1 Q    count+=1
- n( ~  F( D5 F2 sprint(sum)

count=1
3 {+ Y) O9 n* Y# [sum=0
while count<=100 :
    sum+=count
    count+=1
. F/ c6 j5 z! E; Tprint(sum)29、元素分类
/ D  A. d# Z) o! Q+ J$ `有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
9 s  @) ]8 c3 A% v7 N$ Z3 y将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
& R6 _2 P" ^  Y7 j+ q: v, Hli=[11,22,33,44,55,66,77,88,99,90]
7 `* G. v9 T7 G% C$ }* u7 W% qdic1={
    'max':[],
7 ~0 f4 O7 I, H" u5 r    'min':[]
}
for i in li :
    if i <66 :
6 F* @, h# y  I8 M, W6 J        dic1['min'].append(i)
1 Y2 t" ~. K( ]2 R    else:
        dic1['max'].append(i)
7 U4 ~' a- A& l/ v* T0 [print(dic1)
4 w* i. f$ ^) ?8 E/ G$ `
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}