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

  T! c7 _. Y4 D' V5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

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

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

$ g! g( l* N  {- g& Q# y8 r10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
; n+ M' O. a5 C7 K0 [1 w6 @    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
8 l/ i( p5 M# |) l2 `/ Qcount=1
; r7 S7 l- Z' U9 |" `$ ~* C' ?  _7 Vwhile count<=3 :
    name = input('name:').strip()
4 [+ A$ t  {0 v# S& m' L  s( j    pwd = input('pwd：').strip()
+ H8 G6 Q$ J" c6 h
) A. Z( w! H  e9 y9 F    if name=='seven' and pwd=='123' :
        print('ok')
    else:
, G7 N* z/ |1 j+ v! r( d        print('error')
        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

. O2 T1 |8 r% E1 W- Z    if name=='seven' and pwd=='123' :
5 n- P* U% a- d+ K        print('ok')
4 @7 P  O1 F: N    else:
; b# Q3 E" o& _+ A: f' m        print('error')
3 o& |6 o: I! O" e- e6 H        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
# U9 _* O% k. i  F( ^    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
( h9 f$ ^! w1 P7 E$ @* e    else :
- y+ M9 {9 V* V, T& K2 Y/ ]        print('error')
        count+=1
( X9 L. J) Q0 M3 g! qfor循环
for count in range(3)  :
% u$ r! K9 }3 ~    name = input('name: ')
    pwd = input('pwd: ')
; A1 @, b) h5 L! E9 y    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 u* s) E0 N0 }3 h( A9 s        print('ok')
    else :
        print('error')
4 ]9 O  G, u3 O+ ~3 q6 \  Q2 W        count+=111、写代码
- \0 x, M  B% w' Pa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
* v! V3 G* [: H2 mwhile count<=100 :
2 E0 |5 Y+ b8 i9 O4 M    if count % 2 ==0 :
+ j4 @; D) H' Y) ^0 F8 W  B3 }        num=count+num
% P' g% _: y& M1 p* O% k        count+=1
    else:
$ B6 q: K5 y0 X6 o* w& }1 B1 X        num=num-count
        count+=1
7 [9 i% k3 S- f) O4 |# E  A- Wprint(num)
* Z, Y2 n1 X/ D& o0 o
5 \9 c2 {- j5 f* v- x( S1 pb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
print(num)

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

5 I; \9 ^2 l! n6 C% bcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
. ]  c# P8 i& E3 T( ~: b1 Wfor i in range(101) :
5 q9 `9 w% \+ S0 F    if i %2 != 0 :
        print(i)

count=0
while count<100 :
" Z4 E- ~" S2 D" R! R    if count %2 != 0 :
        print(count)
6 \' G+ `. p# r" \1 o    count += 1
2 {9 y# R. ^: h' Q
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 j+ t" x5 J: g9 I) S. G! h    if i %2 == 0:
        print(i)
, M' w, n( A3 Z, j+ L
count=0
while count<100 :
3 f! A  w- ~0 B, D5 F4 c    if count%2 == 0 :
: \# n. G& W& T& n        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

7 ]" U. f: z/ c) ^0 ?5 xprint(bin(5))二进制   0b101
- i# R2 i) L( T9 c4 p6 x+ Sprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
/ K) U% r$ a  r' H14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

5 j3 V6 m7 g2 ?- X3 ]% U: u
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
( g& f2 {, D- qa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

+ {! P; Z, y  G5 Q2 @4 |b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
) k2 m/ t7 Z9 W3 f0 {8 O: e( ac. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
0 G8 y. T4 i$ C$ [, \# h2 od. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
& ?  K. b+ A( P! z$ U$ e: O% Kprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
0 [- z; T; q' `! p- Z7 l- z+ `
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

( p7 k" L) k( J2 h. P/ H0 Kj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
( S1 `6 {/ q7 k+ s21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
5 q% |% j2 W2 U6 Z- `for i in range(len(name)) :
    print(name)
for i in name:
' Y8 E3 S0 V& s: i5 I+ E$ T& F    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
3 I9 @! e: R6 l1 C7 z22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
$ M$ ~! e% z5 dprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
$ j" j/ A/ Y3 _2 l& j3 A% j  @ ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, s+ Q2 K- I7 N# T4 dprint(li)
- i6 E2 O0 E+ k, }e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; Q$ S$ C" F6 C4 `' z$ Sli.pop(1)
print(li)    ['alex', 'rain']
% c7 `' o/ T% F, a' n- k$ }指名道姓的删除li = ['alex', 'eric', 'rain']
/ g7 F) c0 m' q4 X, Xli.remove('alex')
. V2 J. L$ u$ {7 n+ \4 w- [print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 h  s* @: b. o0 G% @print(li.pop(1))
print(li)
* W- e3 T) ~, m$ i
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
7 [& l4 I9 w4 Q0 Q6 m8 L- ?; Jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
+ {' o  S% @* J/ E    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- n/ |$ a( G7 S. O$ Sa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
% p9 J, E$ m# Z6 S9 eli[2][2]='ALL'
% e' A, ~. E6 _1 e! u, V! yprint(li)
9 f1 C8 `) r/ N( C) q24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
( A& q" Y; Q8 l- v4 H/ `a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
2 J7 N) }) `. i4 k9 [( hprint(len(tu))
+ e) L5 M8 d7 m( c/ O& mb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
/ q% A# H- W. v) Sfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
/ W; C. \4 W4 H4 k% ^3 u" K    print(k,v)
10 alex
11 eric
12 rain
; Z! f. Y! ~3 ^
for k in enumerate(tu,10) :
5 W3 ~' ^# m% @: \/ L1 t. |0 h    print(k)
) E) w! G4 y2 ](10, 'alex')
(11, 'eric')
" D: x# C6 l2 T6 e6 o1 n(12, 'rain')
7 n* S3 P2 B0 C/ _; n5 k

# O, x  |5 A+ ~' ?25、有如下变量，请实现要求的功能
9 F% p9 Z5 ?% ^/ atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% q9 p' }0 S, A- a! T0 P( qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

" z) z' w: t, J* V+ jprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* v5 I& b4 v$ k/ r    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
% X$ ^. T, z# \( F/ dd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' e* S; @' L3 m! `- G$ P) Gdic['k4']='v4'
% k+ d9 V( t; Nprint(dic)
% C+ s4 U$ i* T  X7 g8 F) m( Be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
7 J' Y7 M/ j1 l6 S; ]5 B. odic['k1']='alex'
# K' K& l9 F7 A- Dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
7 y' v, t( w% _0 ?. Gprint(dic)

5 J4 T8 w, c. T, f3 ~! ?& I& rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# G. ~3 E/ d0 B' h# D, t3 t+ Adic['k3'].insert(0,44)
- g8 y4 b8 s% V7 |print(dic)
1 H* [' j; |/ T! v3 n3 O27、转换
* H( o) z* y7 a! ~- Ma. 将字符串 s = "alex" 转换成列表  s = "alex"
' k: u9 K/ y0 m" o! z8 I/ |
# [4 Y$ _. A6 a3 Oprint(list(s))b. 将字符串 s = "alex" 转换成元祖
- Y4 [3 h5 x" Ps = "alex"
! R/ h4 ]2 |/ {5 s2 v4 c% Rprint(tuple(s))
4 p/ y2 M) s8 d
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
5 L8 T6 m7 ]0 t2 H/ [li=list(tu)
! ?2 y7 ~% J# W5 rprint(li)


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

dic={}
$ q* T& ~* E) {( H. nfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: e# C  B$ |! f4 ]. n! n* U% z- ea=n.encode('utf-8')   
& s) M! z0 p7 e8 ~! j/ Y1 h6 jprint(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% `+ i$ W9 w3 I  H& c, rprint(a)
b=a.decode('gbk')
, E2 C) Z" j. p& U2 X! I! zprint(b)28、求 1-100 内的所有数的和
/ N! G4 V2 Y6 Z, lcount=1
5 S# V( I! K7 R) {sum=0
for i in range(100) :
9 U8 q) E: \) H. i& ?    sum=sum+count
    count+=1
print(sum)
8 i9 I' c% t8 @4 u+ s6 P7 Q5 J& @
count=1
9 G+ ~+ J' @# O' jsum=0
9 x: O! x* g. u; A; Twhile count<=100 :
    sum+=count
    count+=1
print(sum)29、元素分类
  i) P* l8 H% x4 d有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
+ \# H4 S, X2 H' c4 g1 `+ L将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
5 ]( I' z/ |; v2 q% g, y: Gli=[11,22,33,44,55,66,77,88,99,90]
2 u4 I7 r0 ]) e3 j. @dic1={
1 u9 L3 y' [4 g6 l  @- a% a' D    'max':[],
4 J) g$ V" u2 W; i  {( S; F4 F' K    'min':[]
}
: _2 v5 a- B4 G; L- O% W, Cfor i in li :
    if i <66 :
: [4 A  c& c; r        dic1['min'].append(i)
# [8 j: F0 U( o' A; {! Y' v* \    else:
2 ?! D, \7 N+ W$ p, O; ?        dic1['max'].append(i)
/ A1 Y. S) V: `$ @, ]print(dic1)

+ H4 U8 ?# N  h8 t7 d6 Z---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}