Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

5 Q( T% V0 @: E2 O. a3、简述 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

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

单行注释  #

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

- q# F4 x$ s* v; [6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

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

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

/ {. k4 v" R/ @) Y  k- V3 t2 R10、写代码
  J: S) Q& n2 x% oa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
' B1 A" I3 r6 i! t$ d, xname=input('name:').strip()
4 P$ C" t7 i  b+ e4 m1 r" J* npwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
) Y. n! o- _: t. Z4 V! i" ]/ h    print('error')
9 }5 Q  |/ Y& H& {; e% J( `
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
# L4 r1 N* h4 _- z6 U) X* B% f$ Ywhile count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
+ x! u! G8 W8 k8 n: t
+ ]7 h; f* j- i* |7 a& o    if name=='seven' and pwd=='123' :
4 g# @8 t3 q( {1 @5 [( @$ ]+ W3 W* ?        print('ok')
+ R8 @6 y& x: T4 Y    else:
        print('error')
        count += 1
; c% J+ m) A) ffor循环：
for count in range(3) :
" I, h% b: C. f* f; q5 d' q    name = input('name:').strip()
    pwd = input('pwd：').strip()
, H: N) F3 w7 H' S
    if name=='seven' and pwd=='123' :
        print('ok')
1 D. `6 m3 t5 i: g7 A    else:
( r* K+ S" t* T) b/ s, D& f% e+ e        print('error')
* K  ~5 p: Z* S        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
+ R$ {9 `% @6 ]2 p! u$ Hcount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
( j7 A( [6 j+ ~" ?  o    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 X& h* r& @: P6 V3 U        print('ok')
9 b3 t! ^( \8 ^0 b    else :
5 \; O0 d. y* v        print('error')
. q* Z! i- N3 ?7 I6 C        count+=1
8 k/ a3 I" d6 v  Z" \8 A* Gfor循环
3 _9 h+ h5 S, v) t, e3 Afor count in range(3)  :
2 Z. L/ q2 h6 G    name = input('name: ')
7 u+ M  W$ \$ Q0 J' K0 _    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( I* L0 H) m' l0 \        print('ok')
    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
6 g5 ~/ [  Z% Ycount=2
num=0
while count<=100 :
/ U/ ^. p! N: O1 l" g- s6 W- {    if count % 2 ==0 :
        num=count+num
- y4 m2 c/ P' w. r        count+=1
    else:
& u* q8 n7 H0 V+ d  ]$ c& ^. b        num=num-count
5 [$ e8 T$ R( g& i  ~        count+=1
4 w/ N/ {5 A$ u: Z  U* Jprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
% a5 v7 V2 J& S' H9 e5 \9 R5 hcount=1
( K- R- ~; V: @7 Lfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
7 t6 x% Q$ E4 |% _        num=num+count
print(num)

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

count=1
( A) Y: R1 ~4 h: ~% V& q) {- Lwhile count < 13 :
    if count !=6 :
        if count !=10 :
: `' C3 h# X3 T" O- {            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
7 S' }1 M, @9 c        print(i)

count=0
$ G- e0 h' u0 o% [% M  Nwhile count<100 :
    if count %2 != 0 :
# s* z4 }: s4 P& T" R1 \        print(count)
7 ?' T' {  m7 N' b    count += 1

; H6 F" \1 o2 W, X) f6 b2 De. 使用 while 循环实现输出 1-100 内的所有偶数
( ], s9 t5 Z6 n0 a! rfor i in range(100) :
    if i %2 == 0:
7 J; d7 V, n- S7 v4 k# D) ?7 \        print(i)

# w' j4 G+ y5 k  q" K6 o  O  @count=0
9 v" u9 v' i0 i* P& J2 n" |while count<100 :
    if count%2 == 0 :
% v% z2 h  n3 P8 o9 g' S4 ]        print(count)
    count+=1
8 U3 `+ s) r" k- ?( S% q% H2 m
  U* ~+ Z0 G- ~! O12、分别书写数字 5，10，32，7 的二进制表示

/ b! h8 o* H+ B) l0 _print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
) |+ a+ |4 L! u4 K$ Q, |1 k  b14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

/ T4 [2 W2 l1 C* m$ g+ t16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
7 u# u% y8 P: u- W; ]* }4 T17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1))  结果  3

5 D" f7 e3 {& H; z2 @2 x  G- I& m
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

" ]2 C( w" d5 O  Qb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
2 D! T! ~$ t& @, ^0 ~: lc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
) I, p" U0 P% ^8 B% V# n5 c$ Bd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
4 e2 A9 ]2 x  P5 p) {" Hprint(name.replace('l','p'))   apex  
7 N4 I5 {* u' x7 [+ C! se. 将 name 变量对应的值根据 “l” 分割，并输出结果。
+ v- `2 a1 J1 N! G4 N0 V: Wprint(name.split('e'))   ['al', 'x  ']  列表
* h* Y; w- p2 T% k( n
g. 将 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 循环每一个元素?
2 m7 p# b: U- C4 _$ P! h3 X6 e( N依赖索引
name = "Alex  "
6 d  c" \( B( P7 ffor i in range(len(name)) :
, c% R5 ~7 d5 q( Y    print(name)
# N5 }$ v1 e' a' e7 ifor i in name:
7 \( J" w. \8 C; A: W    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
( X5 _/ z2 y$ n& ?0 v1 f22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
. d3 u# a8 d. l' l  |3 ^print(li)
) d: r  Z; T5 G- R2 [% \ ['alex', 'eric', 'rain', 'seven']
) _6 E+ A! S( Y6 x! Z3 C' Uc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 B/ q- Z2 X2 g! Q2 I: ]' t( tprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
% N2 f5 c: R5 h, ee. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
( w/ Y3 w: ?1 I" h2 b3 z$ nli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 M0 A8 i: ~) tprint(li.pop(1))
  d, g1 j7 i8 nprint(li)

7 M, |8 j5 n0 Y/ o8 Z8 feric
; u; J' Y) x0 t5 S4 M['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
" N2 j- M2 C- J2 ?print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
6 |9 d, O6 o3 r3 [5 x# p    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" P! Y2 ]4 p0 Aprint(li[2][1][1])
4 B  l9 `& Q6 H/ m7 Vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
8 B3 o7 E1 C' Q* U* e& |li[2][2]='ALL'
& r! j( D/ S( G0 M/ Oprint(li)
% S0 |9 ^  u6 z$ e' I9 g24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* E; C0 ^* D! r5 ?( ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
$ ^. z! m  Q3 b: Bprint(tu[1])
2 L( ?, x# \' ], K8 te. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
" G. S" j# ?' i9 U  ^) I0 P9 Vfor k,v in enumerate(tu,10) :
' r% @$ n8 O* @" h0 L1 ^! ]    print(k,v)
" u' D6 I  z& R' W# z% m. }# N% L10 alex
11 eric
2 y/ P' m6 h) \! o' R12 rain

& O' }. ~$ ^1 f- `for k in enumerate(tu,10) :
" P: v8 I/ p2 ]4 y7 s# {* i/ i$ \    print(k)
(10, 'alex')
) x4 e! c. U, q/ l7 H(11, 'eric')
(12, 'rain')


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

元组，不可以

2 `. E) V9 P- pd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
; B9 I* S' S+ |: Y$ X4 w! T
0 \- y: E+ ^# E& A1 uprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; U" v: p0 u; \7 w- ]1 @    print(i)b. 请循环输出所有的 value
for i in dic:
1 F/ M' m2 P( _, h9 C    print(dic)
+ h, q/ P* z+ O- \; qc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
7 p, k6 y" D  o" r" U/ j% kprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
/ t$ a. m4 `7 lprint(dic)
; D9 {* C5 c  L' ~! I# e
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
0 [1 [' V* j# _dic['k3'].insert(0,44)
print(dic)
  \' l8 k* R% y8 I. j+ t( p$ R4 g27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
! l. e; b) u- H1 \print(tuple(s))
. I9 t" q% u$ |
: C3 R) y2 B# A- k7 vb. 将列表 li = ["alex", "seven"] 转换成元组
9 F/ {# B8 @3 J  S) g! {" ?li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; w% e# [5 O/ r9 J4 a+ R+ Rtu = ('Alex', "seven")
li=list(tu)
: S% {8 t9 D5 ?5 q3 M6 [print(li)
, H' ~6 n( }. V+ w  m! N, J4 z

1 b+ Q, N: ]" e5 @5 f* Od. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

4 M0 p9 F& l) ~7 ^, T; A7 c9 Vdic={}
8 Z  Z. M8 k+ p9 q% Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
8 H* }( w! a3 V1 X2 A/ B" a1 d    dic[k]=v
    print(dic)27、转码n = "老男孩"
; g  D: v9 h+ D" Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
6 Y" Q! F& b% v' f4 V1 u- Oa=n.encode('utf-8')   
; R  W. G1 X( t5 q& B" [8 eprint(a)
( P" S# s) k) _3 {b=a.decode('utf-8')
6 S( I& }7 |" L; K( K8 q% Mprint(b)
8 @! O9 L) o" k5 C' }7 {5 nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
+ ~5 N' E6 _2 F4 u8 |. hprint(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
8 c" g7 d9 @2 A# d- k4 Qcount=1
sum=0
for i in range(100) :
    sum=sum+count
) v8 c! [% D0 O4 h! j    count+=1
print(sum)
" {/ s0 c1 M/ l2 U) a2 O
count=1
sum=0
while count<=100 :
' B& R& c& W9 y( p+ ^8 H" ~. l    sum+=count
    count+=1
print(sum)29、元素分类
' u2 x4 R, E& U( s有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
% z$ C% `6 n9 }# l7 L. O& l! hli=[11,22,33,44,55,66,77,88,99,90]
dic1={
+ i9 i0 G, E# r2 y, l3 h9 j' }    'max':[],
    'min':[]
; m7 o2 D- H" R" @: r}
for i in li :
    if i <66 :
/ _) J  t* `4 i) A        dic1['min'].append(i)
. |& t. ]* T) {- Y    else:
        dic1['max'].append(i)
0 _: q5 f& j5 H/ R: Kprint(dic1)

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