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 S# ?9 h2 S0 _4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

0 U' k4 M: B5 W2 C7 V: x9 c6 C5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

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

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

10、写代码
" t4 E1 q7 M: h! S4 ?a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
6 T. x/ m" L, i: d, E! @name=input('name:').strip()
pwd=input('pwd：').strip()
- _$ H4 M0 b- O% Gif name=='seven' and pwd=='123' :
% E! y7 D1 e1 t( z    print('ok')
else:
6 {1 |% V% V. X- d, x  Q5 z9 {* a    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
, O7 a0 f- k1 [2 o5 J* x1 wcount=1
1 W+ N5 y) W* \8 r4 r# ?$ Twhile count<=3 :
  @, q3 |! ]& @) k/ h( D# C$ r    name = input('name:').strip()
% r- Z! a/ o% }) i: ~8 c' m    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
$ ]( Z9 A$ J; p* H# A- p% _* U    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
& ^6 `: U- [% G: v! i) F0 ?    pwd = input('pwd：').strip()
) y  G3 m, M- g+ s5 M4 A& o5 t8 x- i
$ \9 v( T! w  A+ \" m3 }3 D  ~/ F    if name=='seven' and pwd=='123' :
6 |6 a5 ?' J5 i- F$ t$ g& H        print('ok')
    else:
6 ~  ]2 H7 o) t        print('error')
5 j8 q; M/ c& d' J; Z9 L, y1 J0 l  }        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
: g, j+ A/ ^" z1 }, }5 t! p7 w  Jwhile count<=3 :
    name = input('name: ')
, n' Q+ |2 P; g9 ]& `    pwd = input('pwd: ')
- ]4 C( |1 v% n; o) y- s    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
5 u# x; m$ c) R9 v* b' t    else :
: p: X0 b+ L+ R+ G, Y2 }        print('error')
, M9 [4 p6 G& Q. v" U! ?        count+=1
for循环
8 m7 C/ O$ M. W1 _& {for count in range(3)  :
- G1 v" m& b' v9 \: f    name = input('name: ')
$ R  {" v4 O8 Y: T7 x: Q    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
3 f8 `" N& u/ p        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
' U6 ^! i" X5 e" _' ~- Owhile count<=100 :
    if count % 2 ==0 :
        num=count+num
2 V9 s; W4 w7 L+ r        count+=1
    else:
2 i( `# ]0 U9 g        num=num-count
        count+=1
: T  v1 z- c* K0 Nprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
3 D: u. v3 X6 D, u; j9 X8 ^' F num=0
count=1
for count in range(100) :
( t6 q$ s' k! j, r! m    if count % 2 == 0 :
        num=num - count
& }+ j  V- Q* Y. F    else :
        num=num+count
print(num)

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

count=1
while count < 13 :
9 t4 v, s8 E6 z    if count !=6 :
        if count !=10 :
: K& X8 G$ y7 k: y            print(count)
( O" F' E- f0 T
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
6 ^; `4 S: D) i' ]0 ^- I- r0 Efor i in range(101) :
8 P1 _  ~* c; H8 Z3 Z( L" l    if i %2 != 0 :
, v2 E- y. Y8 ?' r4 Y3 g2 a        print(i)
  ~0 D5 L$ D: b$ G* W# F& f
+ O$ K2 E/ Z/ e( W& Icount=0
1 a( w" I, e, iwhile count<100 :
    if count %2 != 0 :
        print(count)
    count += 1
5 x8 k0 [+ b& |  g8 t0 D
e. 使用 while 循环实现输出 1-100 内的所有偶数
* Q$ J0 {) C; W$ @" G0 T! W& a/ Afor i in range(100) :
& I  a' O, H" {- [4 ~    if i %2 == 0:
        print(i)
8 g, N  ~3 ]' Z! F. G. g  t' M3 M* K) c
count=0
, E- g* k6 b# n8 D5 E9 ~9 Gwhile count<100 :
    if count%2 == 0 :
2 U/ A( r! a1 z* b* b& K        print(count)
    count+=1

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

: X& M- m% T3 ]1 qprint(bin(5))二进制   0b101
  W. e  a- a0 s8 nprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
' C# K* j% J5 }" i9 H, f14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
5 ^. r% ^/ `0 K  P& F! N" Hprint(int.bit_length(n1))  结果  3

! J/ ]/ m) E/ h* {; l
18、布尔值分别有什么?

False .Ture ,或1  和0

8 l+ |- n1 g& W: R20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
" F7 N5 \5 t  M4 C5 p( r' g) k2 s$ ]; Ma. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

1 g: o, n/ L1 m8 Yb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
( @0 s8 g2 I* I' l/ kc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
" n8 G9 T0 g2 H  [d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
6 H5 K. V, U3 w1 F6 w! q% qe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
8 j1 s" F+ E% @2 x& r4 A
- w: C  l, {* v$ ng. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
( d! V, B9 v( x
& p9 e' }( k' ~! Kj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
( n1 W2 y& l' w. e* n# ~/ d3 k5 `name = "Alex  "
for 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
0 u9 r, Q1 d) L( ]( a$ B' _# P; V- A22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 H$ h/ F& O5 b6 c* e4 F# Q3 mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
" w3 E( D, N% D7 I' {( [c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
2 ]8 i/ n" ~; j2 Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
/ u& T0 [3 G  D2 a' Zli.pop(1)
2 b5 s( ~3 S8 y8 ^print(li)    ['alex', 'rain']
( X+ p9 t" |' @6 l1 K7 ^指名道姓的删除li = ['alex', 'eric', 'rain']
6 r0 ~2 {1 |- ]0 R! c" ?- ^li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
  w) P; J4 T! i/ L6 aprint(li.pop(1))
print(li)
1 K. ~& f" e5 x& q
" f1 v- X/ ^/ z; B" qeric
& c6 j) b( L  _0 J* V['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del 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]
+ s% o" I- O: M  W$ Za. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
3 m5 g9 U: X6 W) z5 O6 u# H1 Fb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 d9 T* |! r, H1 C1 O5 uli[2][2]='ALL'
: {- z( F0 ~6 A3 hprint(li)
# U" E& s% r! m1 i4 B: W24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! V4 p7 K1 @$ n8 Za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, ^. q" v. K8 O; P% u. Q9 A, Uprint(len(tu))
b. 获取元组的第 2 个元素，并输出
! ~6 Y) z% p+ X1 e. Dprint(tu[1])
% `+ z. z$ R3 d( G+ S2 Pe. 请使用 for、len、range 输出元组的索引
2 u& f) U  Z+ D- [) gfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- E2 f$ W' S, w: t' Y  @for k,v in enumerate(tu,10) :
    print(k,v)
' a4 b$ u% a/ {* m10 alex
9 u, |2 t# Y+ S' V, m0 P11 eric
% i. \; u. K! w4 P: a+ i- w% s, c12 rain
. Z% u8 G+ ^* ]3 s# S" \# u% W
4 {0 ^$ j2 t. `, n) E- U; ~for k in enumerate(tu,10) :
  x. R( J0 v0 m  O9 v4 v; L! q8 d$ C    print(k)
, y' J/ z1 l2 T" L4 c(10, 'alex')
(11, 'eric')
; n: X9 G6 F# X$ G(12, 'rain')
+ b- H5 \3 Q* H/ G8 O: D

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

元组，不可以

6 u, i$ ]* |$ f4 b1 _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')
6 V* F* U0 D9 i
print(tu)
5 W3 m( W2 y4 u$ I( M- f! v2 p) `26、字典
) W/ e2 _5 r) Q2 H' C" t( Vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
! f$ z# R  y0 k    print(dic)
( z0 e- M' z* e+ e  Bc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
, E/ j% s# ?! g+ h3 s  `" Vdic['k4']='v4'
, r4 ]2 A3 `9 ?$ P. N, eprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ ]* l* u6 a' L+ fdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# j9 G9 @7 t6 W6 m5 W  ~  pdic['k3'].insert(0,44)
& O( Y0 u# p1 i  ~" Vprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
# a( f" L% \' w  @; l4 p# }6 L- c' D
print(list(s))b. 将字符串 s = "alex" 转换成元祖
9 i) }9 O# V6 V) H$ Z; G+ }& d9 Q) h* zs = "alex"
6 o) N/ D2 m7 c1 U  wprint(tuple(s))
1 d  ^6 c$ J9 P9 `: H
& f- ?2 T/ I- ^5 Lb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
; Y, c4 k7 y6 i7 h* f( a! [; mprint(li)
, b# g  i$ \' ]5 D( ^0 N$ \

2 I8 P3 Z- T! {1 id. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" k' x! F, {) ?6 B; o    dic[k]=v
    print(dic)27、转码n = "老男孩"
. d4 V3 q. N' }5 ca. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
) R9 X% I( y" i; s- E- a3 j' ?+ kprint(a)
% |- U: |2 i* T) ~4 R9 j% Cb=a.decode('utf-8')
print(b)
4 o1 @1 X1 O/ d$ O! W5 zb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
1 [: f( _" v. g! z1 @: i! ccount=1
sum=0
, S7 g$ C4 B, @0 o4 u7 Ufor i in range(100) :
5 e9 }- a- i6 S0 ]; G2 w    sum=sum+count
! P2 K9 d6 _" Q) c1 Z! _4 G0 F    count+=1
+ Z* R" d+ T$ Q5 {4 K8 c  Fprint(sum)
$ Z6 `2 D) ^0 H5 j% n6 y& V8 A
count=1
sum=0
( y( h  }+ G2 G1 A$ ]1 Q+ `. G$ fwhile count<=100 :
5 U3 Q, |9 [* q' |+ y) l  V! Q    sum+=count
    count+=1
print(sum)29、元素分类
9 O! }4 n1 V- ]" c5 Q* U有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
( ~3 F5 B  |2 P9 ^% p1 _0 \+ z4 l将小于 66 的值保存至第二个 key 的值中。
5 v3 T8 k9 Q6 `( ]/ j即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
. j! e: s  `  p9 s  G9 q    'min':[]
8 U& o) k; ?% Z' g7 n2 J}
" J0 }6 H7 H! B- |. }8 t7 f+ Wfor i in li :
    if i <66 :
" V! b' L) u' E5 t        dic1['min'].append(i)
    else:
' x7 S# e9 ?% L3 h        dic1['max'].append(i)
1 f" _4 @4 K/ ]' n. A6 zprint(dic1)
, J1 }+ |5 z" O0 I" A: V$ Q
3 s+ r6 z# w( U3 T---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}