Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

6 t( T6 n6 f7 e3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

! M+ w2 h- x9 d# u# k6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
0 `( j. ?( }- X/ T8 z# gz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

0 o1 _$ C3 @+ r10、写代码
4 u2 v3 E' E; G# ba.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
7 }$ J: b2 q+ H2 d- E% wpwd=input('pwd：').strip()
8 E6 v/ c( J5 |if name=='seven' and pwd=='123' :
    print('ok')
else:
9 P, K8 X9 C  w* S  \" L    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
. Y" F$ D6 y& tcount=1
while count<=3 :
5 B% J1 Q( O6 v* a' T    name = input('name:').strip()
+ q( Z2 n" ?8 E# ]1 U6 t/ j1 r    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
; F: K4 ]- ]5 B: ?' x$ N* Y3 _        count += 1
0 y5 Z" V( s% @/ F" u# ofor循环：
for count in range(3) :
4 @( [9 q& D8 \; h$ p* p; ~    name = input('name:').strip()
+ |5 u( s1 [9 K  Q" C0 e, Z    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
! |% E4 p2 J" f$ a7 B; T! y7 D4 K5 s    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
- L3 w5 `' H, x" \. lcount =1
while count<=3 :
3 [  }: E0 o9 \  E3 _% p    name = input('name: ')
; V5 g/ d: A$ k& h    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
  x+ V6 }3 f+ z4 t4 B: _    else :
3 \5 ~. e4 q; K1 d$ H" t$ s        print('error')
        count+=1
for循环
2 X/ [: i: D+ ~7 E  c4 Gfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
' c( H# F$ Z; w) D7 j- W, n    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
5 X7 v! k) N% k% ]; _    else :
        print('error')
        count+=111、写代码
8 `0 @: v  K$ ?a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
. }. f. {" \: N( L! [  v3 a( o    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
- w9 i) H  ~1 Y0 u" a  Xprint(num)

9 d1 J  M+ b. d# g/ l+ Rb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
+ E2 r3 T6 n# I1 ^3 A5 i0 Rcount=1
. D' e0 y) {$ B. R  sfor count in range(100) :
  H4 G* M! F( b+ q    if count % 2 == 0 :
        num=num - count
2 L, a) @5 {: F    else :
2 O2 g" o0 M; |, ^* D- I        num=num+count
print(num)

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

0 Y8 k0 Y+ @5 t- H" fcount=1
while count < 13 :
    if count !=6 :
" }( @0 R% \, G4 B& s        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
9 Q# q: P4 n4 I! N( G- U6 B
" {9 l9 L6 k; p4 U/ `- I9 ecount=0
& A1 M" ]9 h( l! ]# a0 C3 |; o* vwhile count<100 :
9 E1 _" F# H6 i6 j    if count %2 != 0 :
        print(count)
; r9 B$ B: e( I( n    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
( _  b* s' [$ u        print(i)

6 e( z# `* N# N$ Wcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
' m! t# B: h5 q- B    count+=1
7 j) V% x7 X: Y6 N
12、分别书写数字 5，10，32，7 的二进制表示
- L4 O6 i6 G% V  Y- ], A
! V8 d- C* \* R* eprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
( l. K" h- [1 _* H+ d14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

) J4 S5 J' ^$ U! L% w/ a16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
1 O5 v1 x9 d! s/ P* g17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

3 R7 ?  E3 K) K! s( c$ M
18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
5 n( g# k* ]6 B. H7 nprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
& c. C, m" M9 B- C( b) E4 |5 G" Ad. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
% n3 r* C8 [3 R2 o/ P, Wprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
, o7 X7 o. n8 [, Q/ E" fprint(name.split('e'))   ['al', 'x  ']  列表

" q6 E6 R( m+ Kg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

: q' c0 u( L- pj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
  m5 U0 l1 o" S' u4 oname = "Alex  "
for i in range(len(name)) :
    print(name)
3 v8 r$ i9 X- Q7 |% sfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
. v# s, s+ O6 r4 M1 B. N22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
# n/ E  F, |; \( y/ Cprint(li)
['alex', 'eric', 'rain', 'seven']
& `3 A+ d0 m& ?. p+ \+ M8 t& ^c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, @, \, U) L( t$ Z4 ^print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
! Y7 C, Y7 b7 Eprint(li)    ['alex', 'rain']
5 o5 n  M- Z# Y# P指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
# i( v3 ^2 p3 S; ?& E! r9 o( [print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
" K3 C# Q3 i3 k2 r: h# iprint(li.pop(1))
; F! e9 F& V# W9 m/ i! pprint(li)

: b' Z0 g+ n5 c- Aeric
2 b9 x  ~- j2 ~* y['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
' B7 y) H$ \& q: x8 {li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
# w3 J2 {  D; v) 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]
) ~: o2 Z( ^9 W; Gprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
% ~8 ]: m3 j6 o& R24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
) }$ ~; x' O) y. Y" Va. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& S) l) }% }- }- n1 n) P6 Rprint(len(tu))
! [( b3 k3 P1 l7 O/ D) W7 _b. 获取元组的第 2 个元素，并输出
print(tu[1])
- ?1 V& g* g0 u, H5 t5 te. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
$ M# A. j5 ]! t& b  h7 |! o    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% \4 x/ [) C5 a2 cfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
12 rain

% y* G3 X% f- P% Vfor k in enumerate(tu,10) :
( d" Z+ |, y! s; S7 I2 Y9 v    print(k)
(10, 'alex')
6 y! r% l( b7 [" W* S+ V) ?(11, 'eric')
6 B  m! H  G# a& m+ T3 p+ D(12, 'rain')

: ?1 M) P. k7 F6 {9 a
25、有如下变量，请实现要求的功能
2 e" r6 J2 ]- |2 O4 H; x/ [tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

  J0 W! V, A+ ~& s8 G, sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

' X: m4 `2 j/ Z* F" o! H+ Y' s0 Bprint(tu)
3 b/ n3 J% q! l, W( }26、字典
/ ]* _& r6 ]* G$ |dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
9 M5 r# I  ?  O, ffor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
" k5 B0 p1 y8 \print(i,dic)
5 Y5 c; o/ H2 w1 a4 e/ \d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& ^# z/ ?9 a' ~% z8 h7 f6 \dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
6 h% Q, N$ u. F) tdic['k3'].append(44)
print(dic)
( T+ h2 c& l$ T9 Z+ w0 w9 N( k( \) Q
; R1 O5 ~8 R7 H! g8 z0 \4 u/ ng. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
) T+ i% A. j% f  ~1 _0 o# B( Sdic['k3'].insert(0,44)
print(dic)
' T/ I. m# _5 t1 Q. m( @/ V* U3 T27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

$ k/ g1 V. i+ Wprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
  j0 N! h0 V% R3 H- r) V/ Bprint(tuple(s))
5 R3 X5 P9 y7 r2 P
b. 将列表 li = ["alex", "seven"] 转换成元组
+ z) o/ V% i3 k3 z5 F8 D( Nli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ q/ N, I# d$ p( i+ n$ stu = ('Alex', "seven")
li=list(tu)
print(li)
' ]) a- u! Z  [' z! G

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
1 y: Z, S! W5 _1 qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
  r% ]# Z; S1 K0 l1 k9 aa=n.encode('utf-8')   
print(a)
9 O0 ~" D& p9 u) E6 Y% Mb=a.decode('utf-8')
6 Y- o8 G/ X0 E' F* zprint(b)
# S3 I0 O% b/ H4 I3 g& [2 o1 wb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 O) l2 |, ]5 ?7 o  dprint(a)
9 e) p6 ]1 R; Mb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
& P1 Z) [7 }6 Z6 I# P! X3 m4 |5 vprint(sum)
: \9 s. ~) w6 X8 f' r8 z
$ i$ U8 g# c* V$ p6 @6 tcount=1
sum=0
. c4 n' l4 X& u: R* Wwhile count<=100 :
# b  Y" l1 O3 p8 t- e    sum+=count
$ N/ o! l9 j; M    count+=1
! S% r/ t1 U! ^9 ~4 A& o7 E: r, ~* E& E1 Nprint(sum)29、元素分类
1 N( |* e  n6 X) V/ k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
. h% b* x* P# ?: i. V4 B5 J) s    'max':[],
    'min':[]
, ^1 b1 U  C! f}
9 f+ Q* t6 ?6 x6 P6 lfor i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
/ K5 Y, Z: f; w/ g        dic1['max'].append(i)
0 v/ j3 o/ Y) }print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! a8 @- H0 d0 t4 `) [" M, ]: d, V