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

5 F$ I" `5 n* w1 A' A& ^, ?8 r7 H. `# Q4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

' C4 C+ W/ H  O7 Q  R; {) }5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

/ H# j6 ?6 k& _7 S( V7 ?. O6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
+ b4 M% l3 O7 o' yz=1
/ C# }+ v7 u* X( _1 Lprint(id(z))
& f- k2 y3 |' M  `4 ~$ Z: V1 J9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

9 ~5 M- F! O( f& d* W9 @10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
, v7 h. f: T' V6 L8 Npwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
) A% R. l! i8 H  _4 s! T: Aelse:
    print('error')
1 p' X) u0 {6 ^8 t0 K8 \! O/ T  o
: Q, f3 C" O6 {/ @/ sb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
' q/ e% ?% \0 d# |count=1
while count<=3 :
$ Q7 A. B9 B: L2 @# u    name = input('name:').strip()
2 C: S7 ^4 U* _- c9 L    pwd = input('pwd：').strip()

8 k3 N2 T4 ^. g8 L' ?    if name=='seven' and pwd=='123' :
( k" H  y5 X& c; Q        print('ok')
    else:
        print('error')
        count += 1
% S( d) Y$ ]7 h1 H  u# }6 g: Jfor循环：
for count in range(3) :
    name = input('name:').strip()
7 f; S+ T, M0 z    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
% S5 |! O4 q6 Q9 T3 d3 g. A  L) ?        print('ok')
9 N3 K# r+ S  Q7 j$ S# Q! ]( g! [. B/ o    else:
3 T' i) H" a5 O4 F) L" R        print('error')
* j+ _$ H" ~3 ]# C# a: j* X        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
2 F! Y! U/ ^8 j! J. i' _" K    name = input('name: ')
3 r6 ?1 V4 N; k, M3 Z- _    pwd = input('pwd: ')
6 g# L" i' e: \% Q- i; u" C  `    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
8 f7 a: ?% `: N! }        print('ok')
8 M: \, J9 o& {# s2 E* o3 n6 @& d+ N    else :
        print('error')
' @' U0 X: c  Y: J9 K) H0 d/ N) d6 T        count+=1
for循环
* k' M6 _2 X4 }* ]for count in range(3)  :
) X1 T4 e; F8 h: z9 n    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
- a8 O4 J  G2 @# y1 [, y; I) }        print('error')
1 M- o5 _; v- C8 b        count+=111、写代码
7 f; C5 P  X" x% |* Za. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
8 l. z! ~; @: A, |num=0
8 b2 s! ]% \; w1 @2 g6 h# C5 y" d; lwhile count<=100 :
7 h$ b" H( I  H& c# o' W" |5 Y/ C& n  d    if count % 2 ==0 :
        num=count+num
  X+ g( y# ]% [  ^! n, Y6 e5 B        count+=1
    else:
        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
9 U/ d5 x' k, u+ P        num=num - count
6 W, ^- ~* g, H    else :
! Q5 k8 u. N( `        num=num+count
* m3 K! }" C0 |8 I( y9 F! s! Q" f2 yprint(num)

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

count=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
5 T/ Q+ B  h% _& z4 \6 e
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
- d+ a1 D# B- Jwhile count<100 :
" H2 C. p; `% T) ]1 K0 M8 P  i% z    if count %2 != 0 :
$ L  \+ @% R# U' b8 h1 A5 Q        print(count)
0 V% w3 P1 t  F, y$ ^. k    count += 1
- v9 d9 }: h8 u( X# E; y
2 ^; r- W* g8 E3 m" he. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
. E3 \6 }) {7 D, d8 V* O
( ~/ [& Q3 u7 J& O; Jcount=0
, M0 M5 T: O  ?4 Wwhile count<100 :
$ ]. r# G8 T, y- X) V* {& P# B9 c    if count%2 == 0 :
+ \& d' [, k/ T# L# U* J4 K        print(count)
    count+=1
  B: _5 s+ x  |; d' I
12、分别书写数字 5，10，32，7 的二进制表示

9 W- a1 t) B+ gprint(bin(5))二进制   0b101
. k0 V+ t/ o. g! n5 r3 ~0 kprint(hex(10))十六进制  0x5
/ p- `* `) Q; P) F3 B" b( uprint(oct(5))  八进制  0o5
& Y" T7 `  ^3 G7 f9 c: p4 k14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

9 {# `( J! \  m7 t16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
4 W2 n- s% l8 v/ `: G. H17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
0 n: D. L) G' l2 K4 n: C4 W/ _print(int.bit_length(n1))  结果  3

2 M) A9 g5 y# s, r
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
6 s- p" v, `7 Ca. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
+ J. E  h9 z3 j$ {2 G* \, x
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
/ i/ |, b* O( F! y. Hprint(name.startswith('al'))
7 L7 p% L1 X7 b! S  ^9 }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
/ Z" [6 H0 b$ l* y2 i& @3 C: sd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
: p0 F( X% w: k/ U; m* b1 e9 o% ze. 将 name 变量对应的值根据 “l” 分割，并输出结果。
8 C. u9 P7 J6 v' Y" ^' h+ sprint(name.split('e'))   ['al', 'x  ']  列表

5 y# s: |+ R% I( sg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
- J% Q/ I/ c+ m( d
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
! C' V. H" e3 `' p% T1 Hfor i in range(len(name)) :
% w/ Z4 o6 [( L. Y    print(name)
" j8 E- q9 }! F& S/ C% wfor i in name:
! e) o" h+ {* D) l% l8 X    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
! M) i" [! n8 w0 `' D  h3 Zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
. b# F0 Q6 `1 P, D& l& Kprint(li)
* Z4 e% |0 Y& }! D) R5 H- o1 m- g) d ['alex', 'eric', 'rain', 'seven']
4 x. _0 R! L& s9 [& a* Cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 d! ]% I- K6 q9 ^2 Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ L* r) z; {1 dprint(li)
3 V; T  T% V6 p& fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
# b% ?* L3 O8 G: _- E2 O指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
3 A+ O6 H- P: Nprint(li)
4 Y; p$ Z! c) G3 |f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
3 ]8 a& u( w/ r9 I7 U' uprint(li)

eric
& U0 x; N" W; k. J['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# e: ?0 w4 b2 n% udel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
" g& `+ g# f; A7 v    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* c0 X) m; b- q  f. j+ b' V2 Ca. 请输出 “Kelly”
  E8 }$ i( h. S# bli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 h) S" \2 R5 f+ Z% h8 xprint(li[2][1][1])
0 \( s2 U! W( X! ~+ Xb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 s9 m7 }7 o2 J8 cli[2][2]='ALL'
print(li)
% F% j# K. a7 p% D" ~24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
" C9 s( a, u/ P1 Za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
) x- j) r* @/ W6 @! M3 g+ `5 X- tprint(len(tu))
* I5 o  {$ `" f" M% ~% Nb. 获取元组的第 2 个元素，并输出
print(tu[1])
- Y- M' `" F. C: w: c, oe. 请使用 for、len、range 输出元组的索引
9 o! X$ ~- ?- j7 I' Y; c, x1 Bfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
: I  W  |6 v: G+ `, E6 k! ]10 alex
# @9 u* G& y) p: ^, S  q11 eric
/ i4 t  b* B" C9 v" t+ D12 rain

& P1 ?$ ?8 z( e) f' Ufor k in enumerate(tu,10) :
1 x9 h" Y! Y& A, G2 `, i    print(k)
/ i0 {/ o5 T4 l6 m1 F. x: g& B( W(10, 'alex')
(11, 'eric')
7 L! m) T& c0 B5 P# b0 A(12, 'rain')


: X6 [% F2 d+ t: e4 t25、有如下变量，请实现要求的功能
" e- c; U1 z5 z% M( U1 b2 \! R; M. F0 gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

$ d2 k) p0 r4 A; K' Bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 \/ u7 R: `; ftu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
- }4 [' _8 _' Q" K2 Pres=tu[1][2]['k2'].append('seven')
: f; y6 O8 S! \& L* `
print(tu)
26、字典
; |& m/ e0 ]2 _$ f1 a; Fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
0 H* D: {7 R0 g+ a( `: Afor i in dic:
5 e% i6 G3 l1 ?2 L3 K! f% \    print(dic)
! |% O* L' h2 k: i/ Jc. 请循环输出所有的 key 和 valuefor i in dic:
! ^" X* l2 v7 v0 ^) Nprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
: x2 u4 R9 [2 `2 d6 ~e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
- r) L5 |2 U2 B, Fdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
3 y$ A0 A2 N6 lprint(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
/ i. c% Y. y/ f6 vdic['k3'].insert(0,44)
print(dic)
27、转换
; l+ D& r& l7 V# l4 w- D3 \& Ha. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 h/ S+ B* Y3 z+ bs = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 }1 x* r) b' itu = ('Alex', "seven")
li=list(tu)
% V% v5 y# b) J1 ]) Y8 ]print(li)
( V7 b5 f0 T/ b

. A$ X7 V6 E- ?4 z# Y$ l. P; i. Kd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
, S* E- f9 r6 z0 X" n) L
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
7 @3 h% Q6 _; m* n2 Y    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" C( b' S& C9 j( fa=n.encode('utf-8')   
3 ?1 J0 @) q9 Nprint(a)
, ^' D5 J# p) R3 u' \0 i" Ub=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
5 [3 |/ P* L; Fb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
( T  R/ j3 M6 t6 a; Ocount=1
! R$ E* i( F5 r& A3 ssum=0
for i in range(100) :
" d6 E& ~1 j0 H7 m4 a# b& _) j    sum=sum+count
. g  _3 k) M/ ]! S$ Y7 n! F    count+=1
print(sum)
6 Z; X9 c8 R0 P$ e3 g
& B0 W1 h+ u. ~: D' U4 Acount=1
. X* i' G* R) A4 {* Z8 z" [% p/ gsum=0
5 z4 l; L7 h9 }$ m9 Pwhile count<=100 :
% Z! M1 }6 ]# U! y. I, O    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
, F, O1 B$ q1 a4 B/ H即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; W# C" v% y) o6 _1 E7 l% Kli=[11,22,33,44,55,66,77,88,99,90]
dic1={
% W. I. W* J% z2 h7 \! |) [: _    'max':[],
    'min':[]
5 ?  a% ]+ z: }  G$ @$ `7 @, T. Q! _$ P}
/ W' H* z' a, b' s& R& @for i in li :
    if i <66 :
2 @2 u( R  b/ u        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
4 h2 @! f* l  Y/ q- o1 [" \; }2 ~
- {6 P# n( o& V2 T+ @: k! [: h---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}