Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

3 v( \7 L% B7 J/ Y, _; C3、简述 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

% w1 v+ N" N4 t/ P% K7 n5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
" U- W9 g) n/ y& Y7 ~) Rz=1
print(id(z))
! Z0 @: M) t1 _% {" P: n9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

; s( K5 x# j; K7 P9 L& T10、写代码
5 y' x$ g+ |4 M) n- M  Y+ sa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
! n) R6 V4 C: H' ?; I/ {9 dif name=='seven' and pwd=='123' :
6 m% }8 D, y7 J: F& F( d; \    print('ok')
; m4 {; D3 v* f0 l+ R1 Q- J% y3 _else:
% Z6 j9 h7 s0 Z4 R* F  n; l2 I* o    print('error')
- O, \! h7 f- q
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
5 \0 y- Y8 P9 g! |! |8 k% _count=1
& z$ {; h6 Y; ]- wwhile count<=3 :
    name = input('name:').strip()
) y4 w9 \, a% {6 b  k    pwd = input('pwd：').strip()
5 f+ t( f/ r' G! p+ y1 v' s
; {# G* D  p: M* d    if name=='seven' and pwd=='123' :
5 `9 p, l+ m. j        print('ok')
    else:
( p: P3 n/ V9 g. o' |6 ~        print('error')
6 f# P7 @' ]  P+ a        count += 1
3 {" c( ?9 I' v# p3 A  d. U" ~* {for循环：
for count in range(3) :
. O: Y, F3 l0 X* P. d    name = input('name:').strip()
+ Y5 }* m# O) |  X, [& U    pwd = input('pwd：').strip()
0 j0 \$ z4 P' S: n
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
( T$ z0 q1 S( {1 T% y        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
; |$ u1 w: h8 ~. z& X; k' Gcount =1
: X- W0 S$ T5 J7 I$ S  r' e7 b! twhile count<=3 :
2 L& q- |% t0 m. E    name = input('name: ')
+ K9 t+ n: z8 m$ O5 K, q    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
/ ~# N0 X( M& B5 N    else :
        print('error')
        count+=1
/ a/ ^, X) N) e: N% xfor循环
8 y8 N) F0 F) q4 hfor count in range(3)  :
    name = input('name: ')
3 K) k& m% v, W. |+ G    pwd = input('pwd: ')
8 d3 L! y+ K3 k' h7 C) B    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
6 g" R' t9 ~( U; s1 U" P, l2 n6 X        print('ok')
    else :
$ r7 z8 M3 l: V1 V; r" b        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
& [5 l+ ]5 w+ ?9 u5 c! jcount=2
* |' D' @/ ^& x: {3 P8 anum=0
while count<=100 :
    if count % 2 ==0 :
7 n' W0 C% q& M5 @) b        num=count+num
* A$ R7 |3 d8 Y        count+=1
+ A0 w) x" s! n7 W- G  [    else:
        num=num-count
        count+=1
print(num)
- X! ~. `: Y: `0 X
3 V$ \$ v: D/ W0 Mb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
  x  k! w2 |  L7 t: u( L num=0
" o) b$ l1 _% m) B& M3 Q8 p9 Zcount=1
0 _0 u0 \7 c' |2 K  W, xfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
: j, c8 }# @# ]  [+ j; jprint(num)

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

) u  R$ d8 o! u# zcount=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
, {3 [4 e% e7 S. U6 g    if i %2 != 0 :
        print(i)
7 _' n; q, N' d
- Z  {# T+ q: m" y  ?count=0
# O2 l1 N0 `  ?% f" lwhile count<100 :
8 w/ m" i5 |2 m' p8 L6 o, w    if count %2 != 0 :
        print(count)
* m+ Q/ H# g' i. E4 p. K    count += 1
; m/ P3 t6 R; t/ D8 Y: u
e. 使用 while 循环实现输出 1-100 内的所有偶数
- q7 y7 r2 Q5 j1 }+ [* O' |0 Nfor i in range(100) :
4 h# S/ L, v  o7 |) d# R    if i %2 == 0:
& x6 T% _9 N+ [, j/ O+ f4 Q5 B3 ~4 Z: k        print(i)
  n6 n2 e: X3 i/ ^7 O
+ d3 r) x" ~; X5 {count=0
while count<100 :
3 g3 b' ~( u9 z    if count%2 == 0 :
        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
3 ?6 _/ }1 V1 Q& |( T7 A1 J" H
" n; y! t5 C6 J9 C/ g, E" p* Yprint(bin(5))二进制   0b101
1 ^$ T% @5 i/ Z2 Fprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
- M9 M  C. C% b7 x. l  _print(int.bit_length(n1))  结果  3

% M) Z6 [( W$ `" r2 q4 k- F
# o' N: Z) X' t& V. V8 [! T7 R18、布尔值分别有什么?

False .Ture ,或1  和0

1 t9 T  d& o- _8 C5 j4 Z20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
/ g. D& M+ g  a: _7 La. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
/ `# ^3 d. O* @+ ~/ w9 r) c( {" pprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
4 J* {6 Q9 {$ H/ B: |4 U4 u3 ]d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
( ?( u" R. k4 x% H4 U% Y, n. h$ lprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
( d1 ~% l2 Q% W+ X- [+ w* `
+ `& `: ?! b7 b. ~" |" lg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

2 j8 Z. N) c1 wj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
! o& k% B) f4 B9 y21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
: Z! t* \6 k4 W  }% _for i in range(len(name)) :
    print(name)
" W$ L" [( }2 J+ Dfor i in name:
1 K; m+ C( d0 ~- }. r2 G" q0 Y    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- @5 O- H0 P' Y" e4 w; x4 f, Dprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
0 j% Y) {& N* D9 j* q7 S8 j1 \ ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- P3 B5 K0 @0 C/ T4 mprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
- d1 S' S, d* Z1 F: Ve. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
' X( k& e$ ~! w! ~0 I: w, r指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
- j. q4 G0 q0 s6 r6 gprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 _1 p  F/ k! P% Aprint(li.pop(1))
print(li)
6 D2 ^0 d# {4 r
7 A% t8 Y. |# E4 weric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 c8 T' X/ I1 S. B4 l2 _0 ndel li[1:]
$ E/ _+ G) V# ^" J0 [, A9 _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]
* _1 M6 o" `2 h1 aa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ k( j$ S4 j* `4 a2 _/ b( ~2 Pprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
$ d  K4 k3 K" ^! O7 {print(li)
" c" R3 K  Q3 M( a+ _6 ?9 P8 s5 I' ]24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ @4 [% b7 A( M# Z  {2 F) Ra. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* D+ M, ~1 T: {- pprint(len(tu))
b. 获取元组的第 2 个元素，并输出
3 ]; b7 d7 z" k: x5 f" a) V( U$ `print(tu[1])
: K8 i8 K3 w- Qe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
, y+ X/ z1 M; w& a/ ?    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 s- r5 ]% ?9 U+ R, D8 Qfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
  i2 @  N+ ?7 L" T- b( N0 T12 rain

7 ?# B. B1 g1 k* a) ufor k in enumerate(tu,10) :
$ V7 `' t1 R. E$ K    print(k)
! H" E2 o, |+ _+ q8 T8 n(10, 'alex')
0 g; ]8 m4 z2 g: W3 ~* s. c(11, 'eric')
(12, 'rain')

9 a. B7 W# M9 r  [4 a
6 E: W6 D. t( j1 S/ l25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

( e6 z/ i. v' S/ W1 ?: Gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) [4 f3 @! G$ ?3 v1 R  Ires=tu[1][2]['k2'].append('seven')

( F3 z$ Z1 }7 v8 {% \( H5 sprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( i- G1 Y) }; V$ M& G; x    print(i)b. 请循环输出所有的 value
! \$ O+ i, w! m2 Q1 H, pfor i in dic:
$ m6 T! F' ~$ y' y* k% ~/ s    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' h% s8 E! P* u1 Z4 ddic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 E: }- T2 u) }$ v, e' F  _3 Kdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 J5 x2 u% x' J  Odic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# h7 F: M  }* |2 e, Edic['k3'].insert(0,44)
! ?- C3 N. f5 V& Kprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

, y* ]' ?  V8 j* z" N* Q+ `print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 m& @( ?! D8 Z. F" o- U% ds = "alex"
) K! C( v6 n- D' I6 t! W6 mprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
7 J( R% _" L4 n5 f& Wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
& H4 Z! B% K# x, E, b5 qtu = ('Alex', "seven")
8 E3 p% C4 A# C/ cli=list(tu)
0 c% d% ?1 J7 ?print(li)
) l/ q: v; }/ F" u3 ?0 M

3 Q4 y7 S9 B0 g3 b% q3 @8 ud. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
- Q* Y4 i  G7 T6 g' k, U5 {: _8 h    dic[k]=v
' O* T: D0 c. ^3 e  B& `2 Z: p  {    print(dic)27、转码n = "老男孩"
' e$ i! {# b$ j3 S* Q2 N! r; Ba. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
5 d! t  I" D* @* I, j0 t0 V6 `print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
6 m( K6 |) C, Z" {; Q6 x' I, eb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
. ^  ?. r6 C. wsum=0
for i in range(100) :
    sum=sum+count
    count+=1
/ _( N. b7 W/ b9 S$ H  Uprint(sum)

count=1
; E, ~8 M: l2 M6 I3 @/ H: csum=0
+ ]) a  A7 F# y% swhile count<=100 :
    sum+=count
1 M5 I$ `# I2 ^3 \" _    count+=1
9 j4 k' q5 H2 `print(sum)29、元素分类
6 v: j7 l  p7 f2 O1 P9 b* S有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
) t4 t; |% T9 O9 L7 \* `将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' Z4 U& P5 p1 X! s4 J4 F  _; Y$ sli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
}
: s2 d  P0 P3 \$ f4 B$ cfor i in li :
    if i <66 :
3 [" z2 b2 G. p" \+ x7 ^        dic1['min'].append(i)
) |$ @+ ^6 C" E/ z. M8 l- p    else:
& y* X6 O' @3 a: O( R        dic1['max'].append(i)
print(dic1)
$ ]8 b; m) W- E- ?! Q
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) x" `6 ]  B: s( {' \( ?