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+ ^! S' C4 Z  s0 _7 @6 Y4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

% |& m1 G- s2 t9 z8、如何查看变量在内存中的地址?
1 A: c# s; @& w. [0 K* x5 fz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
7 ?) K/ Q. t+ K8 }  dpwd=input('pwd：').strip()
& H( ^( @7 \3 o+ V3 k' cif name=='seven' and pwd=='123' :
& U2 `( o* }6 u% E7 r( U4 l    print('ok')
8 l% N" j6 G& V  ^- N5 L! u) {else:
! C% i2 J4 K$ v    print('error')
' r. }8 E  u* g& _3 m8 I
& Q7 w. Z% q6 K5 p1 ~# Jb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
$ X! q9 {0 m7 H) n6 pcount=1
7 W3 a' i2 ^* x: h% Twhile count<=3 :
+ P& K  x- |4 P5 D& J4 O! |) r    name = input('name:').strip()
    pwd = input('pwd：').strip()
6 A) y# e+ i1 O; ~" w# y( J
+ l! Z/ G: G$ y3 H) L  o3 X    if name=='seven' and pwd=='123' :
- n! D! {; E6 W) o, }7 ^        print('ok')
; `6 s/ D% m; C) V' z    else:
6 o' S$ T+ G$ F        print('error')
        count += 1
/ z; f: y9 A, i1 F" x' ~# Y* mfor循环：
for count in range(3) :
& k$ i' i) K! R3 c    name = input('name:').strip()
    pwd = input('pwd：').strip()
! d4 T* Z3 S% c2 L
9 A1 d0 J- x( s" _  E9 s    if name=='seven' and pwd=='123' :
        print('ok')
* i$ P# f- `' r7 J: L8 }6 {    else:
) m, M/ z, x" r4 M6 E0 n8 m) t        print('error')
1 A$ w9 s1 P4 c% L: b! a        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
& q9 [2 i- f( {8 fcount =1
while count<=3 :
2 \* w2 r. z. \) J  ?* q    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
' w2 G9 @# F7 c6 [        print('ok')
! f' {, R6 p- {8 x    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
3 E. o8 \5 v" m+ d    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 K# `& m1 _$ a  }& g5 W9 d        print('ok')
    else :
        print('error')
/ q; p4 F# J  V& V8 d+ z        count+=111、写代码
1 H+ \8 V1 b, Z, x3 D, Ia. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
2 a$ Q# u. k6 A9 Vwhile count<=100 :
    if count % 2 ==0 :
- t' b/ W8 b  D0 {1 y        num=count+num
        count+=1
    else:
+ Z# l0 f( k8 I, Q7 R        num=num-count
& E3 @! n2 W4 r2 j4 I        count+=1
print(num)

' U: {( w- H5 }% Mb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
( u  n1 M- I6 n" b6 e num=0
count=1
  q$ x* @) k& s4 gfor count in range(100) :
5 q- c) K4 v' g5 u, _) _    if count % 2 == 0 :
        num=num - count
    else :
# v3 @, c" T# w: [        num=num+count
print(num)

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

count=1
while count < 13 :
    if count !=6 :
+ `& n6 A7 V1 C        if count !=10 :
            print(count)

* Y4 A& s( C- W6 r4 t$ _6 H2 h    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
1 p1 s0 L- _: D1 Z! Mfor i in range(101) :
    if i %2 != 0 :
        print(i)
# j2 Z- D* _5 U/ z7 e2 [5 N; k
count=0
while count<100 :
; W: ~) k4 N" E# N- v+ @! P; b    if count %2 != 0 :
0 w& d' _, E9 v1 v        print(count)
    count += 1

7 g* N0 {4 _0 we. 使用 while 循环实现输出 1-100 内的所有偶数
6 m3 E0 x9 s3 U* H$ B, g& g7 N# V; cfor i in range(100) :
- O% w2 Z( o6 c/ V8 a* V/ k    if i %2 == 0:
        print(i)

count=0
while count<100 :
    if count%2 == 0 :
. Y4 |/ t4 k, l' }        print(count)
; \, u, u0 L1 s    count+=1

: M2 }) I( Y0 ~( k12、分别书写数字 5，10，32，7 的二进制表示
: N( ~/ X! E! n5 p  Q8 x
print(bin(5))二进制   0b101
+ }( |  b$ {( a& L, g, Uprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
4 G; M8 D' l+ a) T% u2 }print(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

; y. B0 A) n2 e' f% ^20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
) k- {6 P4 i! ]2 Ha. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
  A& t  {" x" J2 s7 o  t. y* q; ~print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
3 L( L' W/ {; [9 Q% B/ v/ w1 o1 jd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
. H/ K/ y% Y+ z% _print(name.split('e'))   ['al', 'x  ']  列表
& q- t+ c4 w) A! L
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
9 B) V4 Z7 [/ b/ D# x
+ i9 B" ?. o) d/ v. z/ aj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
. n3 |6 E5 G( Q1 `' Q0 C) d21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
& O) v% X' q3 y3 z5 f依赖索引
. J8 e7 z2 c6 X5 Y. q) Q) Wname = "Alex  "
for i in range(len(name)) :
% R$ `8 r4 e6 S    print(name)
4 i6 h. w; A% pfor 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']
* W9 M) F5 N5 M" r1 \$ uprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
8 u) N( ?: W0 e5 V' M5 ]print(li)
['alex', 'eric', 'rain', 'seven']
) u% J; t6 {0 x4 x4 t, `' Gc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, E5 B$ t4 }+ }+ \2 h' hprint(li)
% K! B, s7 c( i! Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  f8 o4 T$ i: |li.pop(1)
+ E# F8 i3 O$ v9 }$ @print(li)    ['alex', 'rain']
& j" {+ p+ {! @) k指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
& r% S9 X' n& o- |8 Yprint(li)
, }4 o9 O6 _1 Q3 L3 f7 I
eric
  I! ?) ^6 Z3 ]  _/ V  c['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 \! P( Q3 z5 Z5 pdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
* R% G- t8 f2 A2 H) [: B4 Ili = ['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”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
. h+ \4 p' ?9 ?) eb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  d$ F1 [. `! F% W1 m( |, q' uli[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
9 M1 f; t% M4 R& b1 h" I6 va. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
8 F' |9 M# L$ P+ Q1 nprint(len(tu))
0 n; q9 q  f2 \8 x/ F. m( mb. 获取元组的第 2 个元素，并输出
& {# q+ t9 i$ ], oprint(tu[1])
& T' h! {" \  w3 h) x) je. 请使用 for、len、range 输出元组的索引
8 |$ f# T6 v7 h# H& Dfor i in range(len(tu)) :
" i/ \# @+ V1 W3 S    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
; j( N) }7 z8 ?% J5 g10 alex
11 eric
12 rain

for k in enumerate(tu,10) :
- c7 I6 C) s/ J    print(k)
* ?9 j3 l: Z/ D(10, 'alex')
(11, 'eric')
(12, 'rain')


25、有如下变量，请实现要求的功能
2 [' z) H3 j, etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

% J7 J; h& q4 j* }0 sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
& ?( e0 i7 G* |2 A$ v7 J7 H' u9 etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
4 q& U0 ]" ?3 V* d9 T8 C+ Ires=tu[1][2]['k2'].append('seven')

: ^/ y" O# c& a1 j; n, `: l# cprint(tu)
26、字典
- d! |) e" u( y0 h: f/ ~dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
% m5 T8 ^, ]% K& V& ^$ Tfor i in dic:
# ?) _, ^$ {$ z5 D- F% Z8 Y    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
( X/ R, g2 u+ C0 p2 Aprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
' Y% w3 x) l0 hdic['k1']='alex'
! w0 n* s1 B/ T8 F2 U' X5 h. T: d, Uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
# ?9 I1 [+ }2 w2 n% L& ^+ ^; Va. 将字符串 s = "alex" 转换成列表  s = "alex"
& R. h% r! Q# i, m& N( S6 m6 q
% c( ~8 B6 ?1 u* Jprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
9 m+ M7 \3 Z6 L# K' y1 k& y1 Wprint(tuple(s))
- F. _7 _5 b0 M! [
3 m5 \3 i- M2 d! xb. 将列表 li = ["alex", "seven"] 转换成元组
% y' q$ s3 F& I9 r) g& f1 ~& n' tli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ u" |0 A& @6 z3 u% f1 ntu = ('Alex', "seven")
- P) c6 ?, L6 q9 m" b0 fli=list(tu)
; G& i) b, a6 {% W% l/ W5 Sprint(li)


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

: s+ m$ k! _9 i; Vdic={}
& K! F5 U1 i5 N' Ufor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
+ W. x, I/ K4 G7 \    dic[k]=v
    print(dic)27、转码n = "老男孩"
* M6 g0 P. ?6 Y2 Z) g' f3 c, za. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
6 p  e4 L, q. Fb=a.decode('utf-8')
3 C: \  P* V! M) ]/ ~5 a% eprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 L1 ?/ N7 Q" G5 j/ x! |print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
" z* H3 D$ U- [count=1
sum=0
for i in range(100) :
    sum=sum+count
& S, V3 p* k0 f% K4 {" k- w& f    count+=1
4 ?$ R/ X: Y+ R3 \. L/ w% E% M6 zprint(sum)
. `% w, z" r, Z2 |" k) T! X
# Z# X  w% v, v+ e/ T# Y8 wcount=1
6 \$ Y. B/ d+ G$ ?0 S( @sum=0
while count<=100 :
    sum+=count
    count+=1
print(sum)29、元素分类
" W7 O' Z0 o3 y& ~有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. o& p2 v7 J+ l' y2 f( N8 P, }) R将小于 66 的值保存至第二个 key 的值中。
1 V4 G$ p% u0 a5 P) N' m" o: m即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
4 Y( Y2 G0 q1 b$ B5 _dic1={
9 P- x6 y6 {& v4 q5 e- e    'max':[],
, F: Y9 ]# ~; i, P    'min':[]
4 M7 }& X; C( g0 ?}
/ Y7 v* Q, I( p7 I* F: }for i in li :
: _5 l$ r8 W9 m$ |) K    if i <66 :
& M) C6 y  \! D        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
2 t8 C" f1 x6 P/ f% ~print(dic1)

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