Python基础知识汇总

1.执行脚本的两种方式

Python a.py     直接调用Python解释器执行文件

chomd +x a.py   ./a.py    #修改a.py文件的属性，为可执行，在用  ./  执行a.py 文件

2、简述位、字节的关系

1bytes=8bit  ,2**8=256,可以代表256中变化，

1 J' p0 U! N! }* Z% Y6 \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个字节代表一个字符，

+ J! d9 i4 }* G7 S  }  ]5 a4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

& D0 J0 b5 O0 U, r1 @4 t: y: M6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

" n& r5 R! T5 v2 @" n" @1 H8、如何查看变量在内存中的地址?
( _- n. ]8 G! b1 ?3 t! Lz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
3 o8 }1 F* a2 C8 Wif name=='seven' and pwd=='123' :
    print('ok')
else:
9 U. E- b6 u7 J# k    print('error')
* Q, }1 V0 D9 g
* K# N5 \4 d' V4 N, R7 }b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
& r, v0 }3 `' ^2 Jwhile count<=3 :
    name = input('name:').strip()
8 T3 M+ i5 l% J    pwd = input('pwd：').strip()
5 \4 b/ o* p9 _' C- b$ Y) C; Q- u
    if name=='seven' and pwd=='123' :
        print('ok')
7 `) ]% d( z$ e    else:
. y; x( Q% S6 Q9 O- ]        print('error')
6 C3 ]0 U2 r$ s        count += 1
. X1 F  }6 S: J9 Ifor循环：
for count in range(3) :
    name = input('name:').strip()
0 U5 r2 Z$ p/ @; q- g    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
$ D% r+ {) S: h  W; ?. Y2 [" p    else:
% X4 z/ L: Y1 v" V, C        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
4 y" |3 }) V4 d5 ?' ]0 W. U    pwd = input('pwd: ')
% M; d; {# i4 N0 A6 Z! [: J( A    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  Z* D8 d2 N; f/ ~1 }7 h. m        print('ok')
1 g! ^/ v, e7 Q! d( e  a    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
. J7 n( E5 |0 Z3 t5 K    name = input('name: ')
) t" y4 r7 F" c3 H% s    pwd = input('pwd: ')
. R' `; x& v: Y- |" Q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
" [; p8 l7 @8 n% y  j. s' g        print('ok')
1 E- t/ @0 E% ^' M    else :
% P: R& z! k! g0 U        print('error')
5 C9 e+ s/ B( L/ h, L' `        count+=111、写代码
" S. J2 j& U# Z. H( x2 {a. 使用while循环实现输出2-3+4-5+6...+100 的和
. g7 ^, F3 ^2 F* ]count=2
num=0
while count<=100 :
7 r3 u/ |* d4 t1 L, v    if count % 2 ==0 :
        num=count+num
/ Q7 d1 X) y% v6 u1 b$ S        count+=1
+ y% f* S  }3 F# f- x    else:
        num=num-count
        count+=1
4 ?+ J# |' D/ X$ p& R" j  G1 Dprint(num)
) m+ C5 t6 U9 i) q- H: r
: C, b/ c/ o, u) G! Q6 }: Cb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
/ x$ S* o: c% w- b& f4 W- vcount=1
for count in range(100) :
    if count % 2 == 0 :
8 x( l- b$ ]1 k        num=num - count
" A7 M- q) f7 y  e- d2 }0 l5 x    else :
        num=num+count
print(num)

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

+ K0 I- S# E5 r7 }% qcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
& V) ]" E2 n, M2 m2 g- \9 _# e8 O1 s
count=0
3 z  t7 S& J9 f: ^while count<100 :
9 O! |5 r0 j' F7 [5 u    if count %2 != 0 :
        print(count)
- Q5 N0 R  D7 X+ d4 v    count += 1

% O3 _0 R! n! d1 v! Fe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
/ t, N# W. J7 L        print(i)
4 ^/ R& s9 z: o7 ]5 Q; [- h! K
. D& T, a# c$ a. |' K: K, ?count=0
while count<100 :
    if count%2 == 0 :
) B! y3 x- m) V; X: e" P& j        print(count)
    count+=1

) P5 t1 R; P& v$ X12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
0 N, U$ p% o8 H' `6 G14、现有如下两个变量，请简述 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

2 Y! e& W3 n4 W8 o  ?+ B! {9 I
4 @2 O" Z4 e6 B- P18、布尔值分别有什么?

False .Ture ,或1  和0

# R8 @6 }4 ^& I" _, {20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
! q( x. I: E; |5 u9 _a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
  g& ^; I+ ?2 V  q( U% \
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
$ l9 f: c- D6 z4 C  A$ lprint(name.startswith('al'))
7 b& p" u+ b* j% _c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
, D0 K! H6 w4 Je. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
7 X- z  l2 m, i) K0 ?2 R3 x- Q5 J
* B* X! K9 q/ Pg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
8 L% e! A7 [: `4 w( Y- a! zname = "Alex  "
8 g  I/ u. U/ Dfor i in range(len(name)) :
    print(name)
0 h" O( w1 R& W  ^) cfor i in name:
+ [( a4 x6 Z3 J/ R4 l& W7 Y    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
- T0 e: H9 k/ X; Q6 |22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 O1 ]; \' m2 ~& fprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
8 P+ g4 K! Z4 W- @1 Z6 [+ S ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
5 K& `; L/ d! ]- D" N' A9 eprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
; n. O2 f) c% f. }5 G  Tli.remove('alex')
print(li)
" u2 O9 r; r) s6 Qf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
' q3 y+ z, T( d" B3 Q" m
) L0 a# [0 F6 u0 h, o0 Q# Qeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 R; X' c  f" |' j! W6 T$ Gdel 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”
9 s2 ~; h1 g- Wli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
! f* l# T, b3 i1 Nb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& o* p7 u. T3 O# A$ {li[2][2]='ALL'
1 S8 ?% o7 k4 Q# j. pprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
( d7 w3 H8 D( W2 k; Ja. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
+ k2 u" z. E. y; y" Pb. 获取元组的第 2 个元素，并输出
0 X( W! W. G/ H3 _4 O9 nprint(tu[1])
: d. \! u+ }; }0 Y' _. fe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
( p/ F0 r. f8 `* ^* x; E" r7 w1 Lfor k,v in enumerate(tu,10) :
    print(k,v)
+ r& c% `* h6 K10 alex
11 eric
! |1 t/ D: k* t" O12 rain
* g, n* C' \/ q6 v8 c9 H8 D
for k in enumerate(tu,10) :
; D+ I) l8 Q& c2 ^- B7 X" L3 J    print(k)
: B5 N: O! H$ {! l(10, 'alex')
(11, 'eric')
(12, 'rain')


; P1 V  H' v* Z# m5 s% ^6 O' C25、有如下变量，请实现要求的功能
7 @5 ]& x0 C; Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
( ~3 T  n% x; @1 ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
8 z: O& a0 C# q. O
print(tu)
26、字典
# |# d4 `; T& V% w  Ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* R0 P; n1 j5 z4 k1 I  t+ I7 s) t3 L    print(i)b. 请循环输出所有的 value
  ^6 ~8 e& k! s: pfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
: C5 Y2 T+ M1 d. {4 r+ iprint(i,dic)
! W1 m. b8 T' q' K' Od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 t  E4 h6 H/ q$ i" o& {8 Fdic['k4']='v4'
print(dic)
# @4 X) X$ i( a* x( d4 W: Ae. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
' J/ i8 d1 k7 ~, B& l9 F+ x. w) t9 bprint(dic)
8 s* q# Z% e( K2 k
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
6 r1 d  C  C7 Z( M  Y! P" \& ydic['k3'].insert(0,44)
2 M$ Y5 l& P: zprint(dic)
27、转换
; u7 l. [6 M( X, f7 na. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
4 P. i- B6 q  _" `9 ]; n/ e' m2 Vs = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
' H/ I1 O+ [' Uli = ["alex", "seven"]
: u2 G. u5 T! s; S7 x; o  ]& Xprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
% I3 H/ R; ^4 W' s( {li=list(tu)
print(li)

' ?3 M# `  [0 Y* k9 _( Z  w* E
. e/ W6 T0 @, F, n( i/ i; g/ `d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
* J% t' E/ X( Q: X+ k- M4 j7 i    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, X; ^9 l9 f, h# O4 Q; ?) A) L# i+ Ca=n.encode('utf-8')   
- t& [7 `  c: v, o9 c0 |print(a)
b=a.decode('utf-8')
print(b)
" [3 J: s: K/ K6 X, |b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
* C, m0 o, c9 g( k5 ?" [4 i/ _6 mprint(a)
0 t2 w1 f& o; g$ ~$ Ab=a.decode('gbk')
1 A# m1 Z' x$ v6 f+ j) jprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
+ P: M8 F& g; u1 g
count=1
sum=0
' ^" J: M+ v# [while count<=100 :
9 [8 V9 e8 g; t# x& E    sum+=count
8 D$ m" c6 g3 l- p    count+=1
print(sum)29、元素分类
: e" V! V1 C, k6 x8 V有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
) P6 g8 s! q: B5 n' T; ]将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 p6 h' E4 ^4 y: mli=[11,22,33,44,55,66,77,88,99,90]
; q% {. E& {5 F9 b% V  }; Zdic1={
: }$ ?( a/ c- O    'max':[],
    'min':[]
}
for i in li :
    if i <66 :
) ?& @( p9 ^! e8 i6 x+ T        dic1['min'].append(i)
- g/ c, g; I9 D! D9 t; W1 A. e    else:
7 W/ ^$ `2 q. P        dic1['max'].append(i)
2 H& ?! ^5 o! M: u* `print(dic1)

6 U# m( i) Q/ S8 x( V2 H---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}