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

( M5 }" A* u, Z; [, x( r% d* O4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

5 ~# B  g1 V) b0 B8、如何查看变量在内存中的地址?
z=1
print(id(z))
- A5 j& Z  O5 R6 c7 ^$ _+ n. w- S9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
" O( T  e$ J0 e( ka.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
% O- e# j+ a6 X! ^; i* H" [5 gpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
7 I& V# }) b: w6 c# H    print('ok')
. U: W6 Z/ J5 d8 u6 ^else:
, G  m0 W: y, e! e1 F2 w* v9 Q    print('error')
+ e" m4 V  M' f" x. R
8 |# e. ]  }3 Zb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
; ?3 s1 V! N1 }- L    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
  S+ f: p. i6 F2 ]        print('ok')
    else:
        print('error')
' |- v$ y2 W2 ^8 c        count += 1
+ L. @4 B5 T% h! y9 n( K" afor循环：
& s' O! h% ^7 {# u2 ~) J2 U; P5 kfor count in range(3) :
! \7 n+ {& D( k, n% N6 X) p    name = input('name:').strip()
+ O# [$ f' P5 E$ z& \; b    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
/ o. \( A1 X. \3 a- f5 G        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
1 ]8 F! p& I7 m9 w0 o, @9 K    pwd = input('pwd: ')
  J) h! ?! J5 P( q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
% e  i/ Y! k* ?3 N        print('ok')
& u& W# G0 ^1 G0 k! Q0 G( A8 m    else :
; |  K' r* ~& F. Z' _' P2 N  j        print('error')
        count+=1
' y3 S  }& ^+ E( }% R8 xfor循环
3 Y) a; z8 T7 Xfor count in range(3)  :
+ d2 e, {# `) P# j8 O    name = input('name: ')
    pwd = input('pwd: ')
" J: a( G1 Q' }+ R6 Q2 a- _    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
+ i- S  x3 h" D4 W4 u    else :
% Y- o2 ~8 o0 y9 \: ?        print('error')
7 t3 q  u, t: w        count+=111、写代码
. `' H8 B  h# w) A/ D& |% M9 na. 使用while循环实现输出2-3+4-5+6...+100 的和
: z- B. @" ^* A0 C; k- p$ `count=2
num=0
' G8 a& B" N5 ?% r8 C/ Hwhile count<=100 :
0 a: y4 ^8 _) \8 c7 P* H3 m0 ?# o    if count % 2 ==0 :
        num=count+num
. W( o% J6 S' g! V        count+=1
    else:
- z) I( W7 ]- j& n) u        num=num-count
' E. |5 R5 w2 a0 c3 @+ f7 }, |        count+=1
: L0 ^" b1 u1 U3 @$ H+ Iprint(num)
, z* Z8 s6 W/ W( J8 O
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
3 C8 s$ ?2 M# V9 T! z num=0
) T6 c+ q! @% `* Z3 |. Gcount=1
for count in range(100) :
    if count % 2 == 0 :
# }7 G- ^8 \9 {  O3 l+ z        num=num - count
    else :
2 v0 g- h4 z, D& x        num=num+count
$ R$ Q8 _0 S0 L) Q8 Kprint(num)

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

) @2 s! d: i- O# c% {count=1
while count < 13 :
    if count !=6 :
/ D' a1 q1 H5 ?* {1 l" c* D        if count !=10 :
5 Z1 ?* C/ s4 ]! x3 `2 b            print(count)
3 V1 ?0 S; ~6 `
3 h  L; w$ G  k+ o  }. w    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
' P! N% m/ l* [5 w3 t    if i %2 != 0 :
+ m9 Q' b4 p6 d; F( W        print(i)

count=0
9 K4 y6 D8 j% K4 x; k/ pwhile count<100 :
0 u  ?7 K4 P, C, m# t7 K& @    if count %2 != 0 :
8 V! [5 l% k: Z+ u& B        print(count)
% v0 M+ I: e$ g8 r( N* ~5 p8 g    count += 1
$ ], L5 {& X4 j, ?! v9 J2 D5 F3 j
: S6 w3 `; G+ e( E2 oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ |" ^1 u- E9 ?; `: Z! o    if i %2 == 0:
8 C' g; V; u2 [$ }" i/ i7 f        print(i)

count=0
' G( B& Y. y; w, rwhile count<100 :
& n& p/ @& U+ z( a9 C2 E    if count%2 == 0 :
        print(count)
    count+=1

# V7 t* _+ Q1 {8 n12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
* E" k' v! U) H& K  L5 H( hprint(hex(10))十六进制  0x5
! {0 R" }+ k; t. nprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

' O+ u+ F0 r) [( \( p* n: N16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

7 g, x" v* V1 C( a& V20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
! Z  R( v8 y; V% ^* w- D) G' `a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
9 Q2 D+ {2 f6 d0 _# Lprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
' h$ y  F+ M* Hd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

4 `0 D5 B, t& W' j6 Fg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
& v  l4 q4 x# D! R7 v. M: a3 b6 ?& l( f
1 e, U' L+ n- Y8 E3 V! v  ej. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
- n' P$ q1 K$ O: iname = "Alex  "
) n$ Z9 U5 E4 [* n0 vfor i in range(len(name)) :
# h; E/ C8 C* m/ k8 c7 q8 b; l    print(name)
% z$ X6 ~( f9 l3 U: hfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
& [3 Y6 P, A0 o2 s. jc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
. A( k' |2 a& K0 Pprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
% H7 X' h0 n: w! y0 F指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
$ t& N- f: G3 x; D7 fprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
+ w# M1 k: t5 [+ C1 ~print(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 G  ^0 ~( j) |7 Z1 ~del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( V& Q6 V% A3 i. L6 r- [; Jli = ['alex', 'eric', 'rain']
0 O9 g& Q; O) ]& y& g, Wfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ Y8 V3 {* N' t& a/ Ta. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; Q/ Y+ S' R& w3 rprint(li[2][1][1])
, [9 S  m8 }* _: O0 Sb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
' Z7 C$ U3 G5 Zli[2][2]='ALL'
8 ?; p5 a* P  L) ^print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
) L5 Z! Y& C, H5 I, T/ va. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
& f( g: N) a, g) Ab. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
- U( V  Z; z" u0 S* f    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
3 T& ^1 X& j1 B( ?- m1 ]for k,v in enumerate(tu,10) :
/ h0 @; }! q8 z    print(k,v)
10 alex
11 eric
12 rain

: A9 [- m# a/ e0 mfor k in enumerate(tu,10) :
- o" k2 @' @8 H6 i; Z    print(k)
: |; Y+ J$ k( {$ M5 i(10, 'alex')
(11, 'eric')
(12, 'rain')

2 S7 ?3 y' g- A$ y$ k+ L( P% w6 s
! `/ y; ^2 T/ _0 }25、有如下变量，请实现要求的功能
4 }/ D! R7 h8 _% C/ ?) L- U! Wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

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')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
, A6 S3 p( Q: f    print(i)b. 请循环输出所有的 value
for i in dic:
" R3 \6 j# Z2 D    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
: X/ e& B4 P) P% s, aprint(i,dic)
1 @# k/ O5 Z/ x! n5 m( c' Zd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% {7 ^# k& ?- _8 p5 Gdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ A9 O' t5 I& a7 O" G% m: udic['k1']='alex'
$ ^" i0 Z8 {# k1 ~% Rprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
1 u6 _2 ?; V/ x5 H+ L3 gprint(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
3 P$ m  d4 N0 I# W" Mdic['k3'].insert(0,44)
  x  t  {+ E% B9 \. B. G; ?4 |print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
; h: z! p0 d, S7 E$ J) M. D
print(list(s))b. 将字符串 s = "alex" 转换成元祖
- R% S" ^6 a1 d. U9 G/ W2 p& V- Zs = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
4 }& g" w8 B6 _7 ^print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
" H+ R+ ^0 o1 Lli=list(tu)
2 L: p1 y3 J# D( G& w' t) Lprint(li)
. i/ Z5 v# I) N' [4 \8 O

( m5 H: S" B$ y: |; O8 N' w& L- Ad. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% _3 V) R0 E9 [8 o( Y; t; \
' l9 V4 `2 K$ {# {dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 A( ^' ~" u/ f3 i8 m( L1 Q    dic[k]=v
    print(dic)27、转码n = "老男孩"
3 c4 m, K# I* x* G) @a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
4 t  R- ^# `, q8 dprint(a)
! ]5 R: b# F3 g$ v/ ]+ ~# _  wb=a.decode('utf-8')
% }0 _0 _0 s8 O$ t8 T. k9 T8 a. Qprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
5 R6 ?# |# J# @7 L  ub=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
6 L6 H' ?( L: e1 _( H! t% X" Q9 _count=1
9 Y( J% T* C& ~) L5 Msum=0
/ p$ R1 d( g  q5 ^& D, Nfor i in range(100) :
    sum=sum+count
8 K  ^% U) v1 E1 O: s4 }" i/ K    count+=1
print(sum)

, c, X  t- ^, s3 A5 x; [2 j% icount=1
sum=0
while count<=100 :
. S6 y7 f- Q' a6 c( Q    sum+=count
" d2 ]1 D9 r5 C* ]    count+=1
1 Z$ x) O- _0 {0 Nprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
7 o0 Z# B2 F; M! c; \% o' @将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
4 D" {* W6 C% H3 g+ Idic1={
    'max':[],
9 J2 \: e+ d3 p; i9 w, k+ N  `3 V    'min':[]
}
for i in li :
    if i <66 :
; W0 y  T- D, q3 e        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
7 [; X+ R. ?! t" S. p
0 f3 f3 u9 g  P5 x% [( c---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}