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

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

( o, n- ]6 a! ]) L- l2 f$ T5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
/ o1 X0 D; |" N7 n9 @) }) Dprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
$ o8 c2 T+ d$ ]' z- qif name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
& {! n+ H5 x3 _! x7 A8 a
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
  V) U! a6 V; S6 Ocount=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

) b( w* p5 Q* Z0 B! y4 B    if name=='seven' and pwd=='123' :
+ b- z8 G/ ]3 x6 d, Z) a$ v; }        print('ok')
    else:
        print('error')
: L' F1 u5 ?: U  t1 ^3 l: w* G; w. K        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
% [* @  z0 S; U+ b: Z% R* E+ R. F* x    pwd = input('pwd：').strip()

/ Y6 E: N6 y; |. J    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
' t9 t# J' @! r4 f: Y6 k5 u* r4 gcount =1
, S' O2 N7 P( g* gwhile count<=3 :
) _+ \" C; b0 p8 ~! T3 t    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
5 {! y4 n1 m( V* s% v( t7 f; A        print('error')
) F+ F4 H0 E9 h4 A        count+=1
for循环
# J; w( j. f( H: w) tfor count in range(3)  :
8 J9 ^$ P6 v' a' s  w) N' v( V$ J    name = input('name: ')
    pwd = input('pwd: ')
2 w% o; p6 _( M    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
/ b2 S+ G+ C% [3 U' S% |+ h        print('ok')
    else :
        print('error')
; }' k9 M$ L% {! ]+ u        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
  d) Z, D5 m9 c6 D! Ocount=2
num=0
7 r6 o# ~5 G6 X4 Gwhile count<=100 :
* P- y; w6 Q8 h0 E9 J7 j! j& q  p    if count % 2 ==0 :
" Q: j" }2 i) X# V; \        num=count+num
9 K+ w8 h/ i' f& c2 k2 u6 Q; j! b        count+=1
    else:
        num=num-count
* N7 H+ @# P4 W1 p+ N2 S        count+=1
print(num)

8 ]1 \" t6 f" @5 n. k: I! vb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
) c3 j, a9 _8 R: P; c3 P( o num=0
count=1
- Q& P# \0 S6 ~5 M1 Ifor count in range(100) :
9 w. D2 K8 X# D* @1 _  c9 |5 h    if count % 2 == 0 :
/ P: A8 b$ ~6 \2 O$ ~5 u& X        num=num - count
    else :
        num=num+count
print(num)

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

count=1
' V& \7 D# u; @1 {( e$ p* Hwhile count < 13 :
2 @! B5 [1 @& W$ ~  a" z# \0 O    if count !=6 :
        if count !=10 :
5 e2 h+ b+ X* N. [6 q' ^- t+ P' V. B  @            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
& D$ [  W* T  v0 q3 m3 T+ |    if i %2 != 0 :
* o. x( ]3 [. C- ]6 m  d        print(i)
4 d1 R8 x/ n! V9 ^1 @# D/ ~
count=0
while count<100 :
! b* N& n8 x$ {8 S& \: g9 ~    if count %2 != 0 :
; I' l! j9 c- b2 k/ _! M        print(count)
; E/ _8 r3 T1 F: E+ F2 o; s% m& V9 a    count += 1

$ E9 u8 o: H( h2 ]6 l  K- i: h- Qe. 使用 while 循环实现输出 1-100 内的所有偶数
5 ]/ t; \" D; Q9 ?# t4 ?8 N7 X5 Mfor i in range(100) :
    if i %2 == 0:
+ x" b- |& W0 q; T7 n. \0 f0 g        print(i)

9 ]* R# l2 h& T& @+ z6 B# Z* ocount=0
4 j8 }( w! F* |2 m6 H1 gwhile count<100 :
2 O) y* X* }- \) T3 F- I! ]0 [    if count%2 == 0 :
        print(count)
; f# _& Z: B' [+ z1 R    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

* j. b9 Z  N6 q$ [1 Lprint(bin(5))二进制   0b101
9 @1 i' ~# E* S4 t6 ]print(hex(10))十六进制  0x5
! d6 C+ x. p( V& O2 wprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
; H5 L6 K* x- X" L17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
1 u4 f8 |# g+ t1 _8 D2 P/ s3 @print(int.bit_length(n1))  结果  3

; a, [& V5 B2 ?  D9 G- F6 L5 E18、布尔值分别有什么?

False .Ture ,或1  和0

0 n  n6 D1 @5 G+ w* v20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
3 t5 i; N  ^) ~" [a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
- D) c' D; b4 k9 r$ ^$ Xc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
* h$ b# Q& D# a  L, J0 q& ?print(name.split('e'))   ['al', 'x  ']  列表
% H' z3 g  C) g1 S
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
- ~/ y1 M5 B) T7 h
# q# X7 ^7 d: v7 B) v5 Sj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
% {2 x! w) h" @9 V依赖索引
1 O; _# s# ~; _% qname = "Alex  "
* \/ V! I6 W2 e4 ?' D, rfor i in range(len(name)) :
- H/ N* p% v7 V) N4 d+ M5 g! m- a    print(name)
! I. u' P. P; D7 x: Cfor i in name:
* O" v) N- I3 U) F    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
  f( x' p" ~" ?' w5 ?22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
# Q! D, O! W0 c ['alex', 'eric', 'rain', 'seven']
( m( _) Z6 P) W% O2 u* G  @6 tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
2 |3 m7 \5 F" \9 A% T, ?- T0 Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
. M& l" _" x8 Oprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
. _) @. S- v+ L6 Uli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
* G2 u. S. A1 M+ Q( n$ x0 P6 D% Uprint(li)
$ N3 u# E  D) C0 N
' c' d+ s( H+ L) B  d9 q/ b9 I  z* veric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del 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]
6 R# p- ?* v( o9 l3 C. ], Oa. 请输出 “Kelly”
5 z8 h! @0 j% ^* N; A3 Yli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 x+ O% R& U& E, O; d6 e4 Aprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
# Y% i& B7 B9 u! ^8 cprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
# ^! M, h# A7 `$ Ab. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 {5 J5 l7 \1 _3 W, \6 ^% L1 q( P1 Nfor k,v in enumerate(tu,10) :
8 X+ r0 ?" j5 S* D9 O    print(k,v)
10 alex
11 eric
12 rain
5 v# A  {: N& G0 u7 c5 P  }
for k in enumerate(tu,10) :
/ R# z! V5 x( a" C& R5 W6 x# A    print(k)
; h, C8 U1 `% Y! r/ _/ ?(10, 'alex')
8 o: o  Z2 k6 Y/ X; T. F(11, 'eric')
6 A9 m1 |9 T8 q(12, 'rain')

7 ]$ D4 M' u" |, j& J6 z8 r- y5 o
25、有如下变量，请实现要求的功能
/ J& w, D! M/ j5 L* w# o1 Ytu = ("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])
9 w' W, Z$ l6 C2 W3 A% Nres=tu[1][2]['k2'].append('seven')

print(tu)
4 k2 V8 |1 ]6 H7 J& _26、字典
" u2 b- ]) d$ H0 n% @dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
! G6 |4 Y3 I: E7 K! i: l    print(i)b. 请循环输出所有的 value
for i in dic:
$ c3 I) ]% c0 n$ i+ q9 Y. z5 Q. x    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
8 }8 i& a' b& gprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
7 W6 U1 r+ a' eprint(dic)
9 X7 t- r* {/ ~1 S3 V: z  `; ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

! B9 G2 e/ d& [. hg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
+ `8 m% Y+ E7 O. Qdic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
2 h) M1 b6 D  ?! @. ?. q& h
print(list(s))b. 将字符串 s = "alex" 转换成元祖
! i* y' |; ]( b* R2 T) }" es = "alex"
print(tuple(s))
8 K) J* }3 N/ ]! w  p- Z* J
b. 将列表 li = ["alex", "seven"] 转换成元组
3 ~) W3 l: D8 l% V- t2 Kli = ["alex", "seven"]
7 p7 b3 q5 o8 e7 v, Lprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 f+ t1 v( [; U" U  rtu = ('Alex', "seven")
li=list(tu)
print(li)
' b, [. L( \1 X+ a0 u# d

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- |# f/ R" ?3 t( N( X  h. K
8 [  W% Z8 S8 J- M" B/ d9 Ldic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" y3 u* d# n$ L    dic[k]=v
  P, e' d- Y5 T# F    print(dic)27、转码n = "老男孩"
  J; p8 i4 |9 [$ m3 w( Xa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 s* a/ `" d: ~a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
1 ~+ r: F* B3 p1 yprint(b)
* b8 c+ Z- r6 l% v& v* ^b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
: i9 Y& J2 A. w" ]! f; dprint(b)28、求 1-100 内的所有数的和
6 B& e: S4 R! l2 G; }: {count=1
0 U, k/ V7 D: Z# |4 j5 N3 S. G5 ?5 Ssum=0
for i in range(100) :
+ S+ X1 C8 y! A$ x" Q. O    sum=sum+count
    count+=1
print(sum)

count=1
2 h1 ]; j2 t: w6 g% isum=0
; P$ m5 T7 s$ |while count<=100 :
9 k/ o# Q0 T& U+ T    sum+=count
    count+=1
+ t; F; p/ }# _2 S1 b2 S7 Uprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& C0 x0 d& r8 H8 |  L) P8 J将小于 66 的值保存至第二个 key 的值中。
/ s* n. c6 D. h4 Z( [即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; E7 x7 X% d2 q9 D+ `- Lli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
9 E  u! n* C, D/ O+ t    'min':[]
}
for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)

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