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

; l& t4 J) I+ `! J0 L3 f" ~4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

7 `6 X# p3 `7 N% t* W! n1 o5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

8 Z4 i' H7 Y5 e* P, L10、写代码
! {' ?+ J# b1 ]  E" za.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
/ Q( U8 y6 w, E$ }" Zname=input('name:').strip()
, H1 ]8 N; {3 f+ z$ gpwd=input('pwd：').strip()
) t6 ^" B) ?* [6 Kif name=='seven' and pwd=='123' :
4 Q/ B/ S) v% X    print('ok')
3 C2 `. N6 v' u. P6 Selse:
    print('error')
4 O/ f9 K8 [7 |' S: |
- s( N$ H- K" D- ?b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
6 T  o- e+ m, s: d) w7 |3 {' fcount=1
, l& y7 l8 c( g5 F' |. s- k' V0 bwhile count<=3 :
, Y, d' i+ l# Z2 r  `) H! Z    name = input('name:').strip()
    pwd = input('pwd：').strip()
4 Q, H) V+ W& F  }9 m
4 G# w) M& q. Z% R    if name=='seven' and pwd=='123' :
        print('ok')
. C8 N3 B- k# L5 {3 l1 G: i/ V) t    else:
        print('error')
        count += 1
0 C6 G! c: u+ Nfor循环：
3 |: p5 `% ^* `& j( s1 s* i. pfor count in range(3) :
& W3 S' X& C3 W: W1 A: P    name = input('name:').strip()
) ?( G( }# W4 |  c* g+ a    pwd = input('pwd：').strip()
: |& h' m- P2 Y, t- t' r# \
. _/ p4 ~( |+ b8 a2 \    if name=='seven' and pwd=='123' :
        print('ok')
8 S* q2 p3 c/ z! p- a9 d    else:
3 k6 ~: u8 I) w: e        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
* u# A4 {0 L" n    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
% I1 A( |) p1 ]4 o- \        print('ok')
9 j6 z) V: [) S/ \    else :
6 L- P) y" Z# W# Y; y- J3 E        print('error')
- a0 k2 g9 C% x" e        count+=1
for循环
3 K. N  H1 N8 x. L7 c1 u8 ?for count in range(3)  :
    name = input('name: ')
; a! r7 v4 n6 \. m! b    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
, W/ C5 t7 n/ U        print('ok')
! }& w. k4 g$ c. q5 P1 J    else :
        print('error')
        count+=111、写代码
$ U" i& \; m8 }a. 使用while循环实现输出2-3+4-5+6...+100 的和
  j0 O% L, `+ v4 hcount=2
num=0
. h$ n$ z( l: y9 p- r, Bwhile count<=100 :
4 a) x) Z$ o. `2 y3 B% ~8 U    if count % 2 ==0 :
        num=count+num
; t2 J! @( X( `        count+=1
    else:
        num=num-count
        count+=1
print(num)

8 O. ^5 H+ A& H! s3 yb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
( M  [* Z% ]* O9 G7 h0 t; y num=0
7 x2 L& K$ q9 n/ c6 E* ?count=1
for count in range(100) :
9 d$ u9 I/ u3 Z    if count % 2 == 0 :
        num=num - count
& L4 A7 u  @5 G7 X; u, t5 J6 L8 Z    else :
        num=num+count
- G2 q) y8 ?  {print(num)

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

7 M: `2 f+ q/ r# Gcount=1
4 G1 O) ^2 _  h5 {  v1 q/ \while count < 13 :
    if count !=6 :
        if count !=10 :
1 H+ |$ N' y+ u  V) A5 Y5 B            print(count)
- S7 P! i1 l2 J; H& s
( F! ]$ x+ o* k" a    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
  @) _& l  _+ S( W  g- Y' Y0 I6 Jfor i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
. a9 d& q4 p( s7 J4 k2 }! ~while count<100 :
# S" o9 C: w( q2 c/ G$ X    if count %2 != 0 :
        print(count)
    count += 1

# `4 Z  u8 a9 Se. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
: p$ k1 L6 A& p% O0 X0 U1 \        print(i)

count=0
while count<100 :
    if count%2 == 0 :
! D; a1 |9 K( r; n& S        print(count)
2 d& l6 c. S; e' `6 I    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
' _) v7 ^' m4 z! f
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
  C- k1 r4 h) Y3 Q: A3 A0 G/ C14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
: r) V0 g/ k& v4 S' Gprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
3 {1 ]+ U) c, P- j2 s9 @7 [$ s+ N+ Ga. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
; l; n  U$ h7 B  M
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
7 m. v9 B( U# x- ]7 K( \5 _print(name.startswith('al'))
5 f& p0 x# k- a# U& `( }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
" m9 j' m( }4 N; Q5 E& `
* _% O" g% r% P& R6 w2 k: k+ |g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
$ [; H' F& }& l( q! S* t
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
% g( d, s# \- J5 J/ j1 e! Z21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
8 o& _0 I" \' n3 j7 ]for i in name:
) S5 u7 s/ E& R+ O8 a( r    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
# G9 Z; o9 f8 c/ u22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 ~6 \8 f; V3 R3 W8 u) lprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
0 v5 ?  A3 M: J9 P. ]& bprint(li)
! H1 P7 r! N# I' R2 w5 z& f ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
! |) {- E$ K9 {2 [' l: |print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
7 J, u0 O  s3 V* }print(li)
7 I5 @$ Y; @9 y5 V2 ?e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
5 t$ ^3 f. o  T: \1 e# v4 R& pli.pop(1)
print(li)    ['alex', 'rain']
0 p5 l- [: l' ?' J  f$ O! |. E2 u指名道姓的删除li = ['alex', 'eric', 'rain']
  g4 a5 r) g+ v7 k2 Y' Kli.remove('alex')
print(li)
9 V2 J! S; U  j; D9 Q4 Ef. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 S6 M6 J+ E& ~. G* T. j& iprint(li.pop(1))
print(li)

; Q# t: S; j, q* f& d9 Zeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! Z/ l8 \. Q: E/ {$ s+ }0 Rdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
2 z7 _( t3 E' Q7 oli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
4 _8 H/ K; `$ Xb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 m) @2 a8 w2 p6 l$ ?li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
5 C- `+ j+ \# k! m+ T0 g" v$ N# T8 Wprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
& [: P+ k1 A# F/ h& q: @for i in range(len(tu)) :
8 \9 {. N5 j% s    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# _6 E& T* S! k- c- R7 @for k,v in enumerate(tu,10) :
& f) q# C# N& ]& d# ~4 j+ _    print(k,v)
10 alex
7 ^, X1 S; |4 F( E! ~9 {11 eric
5 J5 i4 G) M5 L8 Z  R12 rain

+ }% q  ^: h( P/ E* Ufor k in enumerate(tu,10) :
$ ^6 c3 z9 z+ {# u( H0 Z    print(k)
' \5 W% @8 Z; v  U3 e: K(10, 'alex')
(11, 'eric')
(12, 'rain')

5 j6 B" o, Q- F4 r& O
1 e3 ?/ V  K( n' X7 N- o5 K25、有如下变量，请实现要求的功能
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])
  `0 k( @$ E7 K1 @. zres=tu[1][2]['k2'].append('seven')

' r" ^2 g/ w" O. ^/ Mprint(tu)
5 M$ K) v$ k3 B# O$ x; N* n0 {26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
) r/ B3 j& o" p: I0 |3 o: Cfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
2 {' P- X' Y. n; N. g* H; O9 R6 Ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& j, |0 {7 I+ d5 T8 B/ Z$ fdic['k4']='v4'
( {2 T6 W. a1 Kprint(dic)
! m1 `1 [2 g! q3 h2 f: w  E0 te. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
+ M" L* D! s& f4 H: l5 Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
+ l; w) l( A3 k. sdic['k3'].append(44)
9 M1 v4 M8 E- x$ c" o2 W% d- q2 {print(dic)
6 x; R2 k5 @8 g, T% l; z, `
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
5 D4 s" K" c( G& n  ~* x27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
) G* N* d5 W( D5 N
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" S9 f' A: y: V7 C8 F; F6 os = "alex"
" I$ T' Z# c. b# t) Oprint(tuple(s))
1 V) ^0 K. J. g4 z
! s, e6 i" m. b! c% v6 qb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)

' p5 Y( e+ u! j1 |  w" G
6 p! p+ Q$ t: n0 C5 _d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
; {. x! t4 }  `9 G
8 g  f: y/ F( Adic={}
0 V* \1 Z$ M: y. I3 N9 y1 Z6 Vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
% `5 i3 n$ f  |' H* V( Ua. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
2 O/ X% D5 z  ^( j6 C' g; \b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
/ x0 I$ S# h' T- ~( E* O: Rb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
, \. ^! A* @2 ]7 j4 {sum=0
+ n6 t: G" r6 @for i in range(100) :
    sum=sum+count
  o' I% y% y& ?    count+=1
print(sum)
" z# y  n' |( I
3 R' j. @0 m: D; |$ v9 w/ S& r  I( ecount=1
sum=0
while count<=100 :
    sum+=count
    count+=1
+ H1 Q! L8 Y  F! q4 @) |# qprint(sum)29、元素分类
) Z8 \; `( Z! k6 y9 w: F有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
- l2 x/ ~$ B' v' @; p8 f6 e* m即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
}
for i in li :
    if i <66 :
        dic1['min'].append(i)
5 V0 n) O* b7 H7 M1 L    else:
        dic1['max'].append(i)
/ s- P* X1 i, a) o; ?; fprint(dic1)
% s: U3 w8 I* f) l  F) J( U
- d* D+ [" h) v  I6 L) X---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
# U5 m+ B4 I* `' B