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

& R3 G2 C# q3 D) I; Q) ?4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

: P+ f* {' z* j8、如何查看变量在内存中的地址?
$ r9 e' {+ O) x6 Ez=1
print(id(z))
( Q4 H  W+ Q5 G. |  o$ d9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

' D8 Z6 N- e$ g$ @10、写代码
) J( E9 y8 G( V  S8 W3 ~a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
7 z+ |+ l* h3 i+ E# B( B; _* x5 O: Sname=input('name:').strip()
( [1 q2 x& ^& @7 Spwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
$ s- U# X8 Z2 F0 F0 e$ Z    print('ok')
- O$ l  K' d( L4 s! `3 v: |0 relse:
, o( o3 m* K  N5 S9 L    print('error')

! y" M$ C! P1 V: u4 E6 wb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
4 b$ H/ W0 M1 w7 Ocount=1
while count<=3 :
: u  Y. i/ C. ^    name = input('name:').strip()
( h  U8 V6 g, t6 L, }) ~- f    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
3 Y# n5 m/ q3 f! G$ |( T/ M( m) U        print('ok')
4 d/ K, {' V! r8 X; q8 }    else:
2 K- q* L& X* L' R% t        print('error')
3 o4 ~" b0 K* @' g  g' k- x* `        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
- I, d  L1 U7 i9 S/ O7 G+ W    pwd = input('pwd：').strip()

' U' e3 R5 @  L) u8 V    if name=='seven' and pwd=='123' :
( i. H1 M2 {1 @( N) R        print('ok')
    else:
# a; B" P8 U* F7 r        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
/ u- c4 g6 n( j' c+ d& A2 q    pwd = input('pwd: ')
/ g: i* f1 H. ?5 G" p2 G  h" @* V% |1 Q3 y    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
- X4 _. B+ @2 m9 D# U8 ~1 `    else :
        print('error')
        count+=1
1 }7 F2 }9 ?$ P+ C3 K, h% yfor循环
for count in range(3)  :
$ g8 c' e! L8 q# T/ r, |: D/ d    name = input('name: ')
% h- C* H% K/ _# Z    pwd = input('pwd: ')
8 d! r0 u( q1 ^9 l    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 {  H2 }& f+ Z* S        print('ok')
    else :
# R: x# z; U' v1 J6 x. _6 s' [        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
. ?  o& t' v! I5 ~3 B) j4 Hnum=0
/ N* C; H8 I% nwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
- G) G& t+ s9 X        num=num-count
) z# X1 j1 H; R" q        count+=1
7 A- k, ~& O/ H; a8 ?- oprint(num)

; M! z9 H) w0 o' K8 _  w; e9 Sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
* Z+ f' J0 w3 ?! ^/ _/ p1 }) T, D  ` num=0
& K/ A7 e2 O$ D& i/ ycount=1
% v- f4 I  `5 }& H& u7 Ufor count in range(100) :
) u4 W6 s. B4 e0 y$ e0 S! p    if count % 2 == 0 :
3 Z  g; S8 X% r' D6 ?  g1 h+ U        num=num - count
- P- y8 P& f- d0 N: d    else :
        num=num+count
2 L4 _7 b: V+ q7 z( ~. qprint(num)

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

1 u2 W, R# c( z* d) dcount=1
$ y' }' T7 H, O) X6 Qwhile count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
0 Y6 Q% F2 x% I( N! u
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
& z; h) O; P, O5 P* u* Z: g' Ufor i in range(101) :
    if i %2 != 0 :
        print(i)
, a7 X6 m8 S( H: ?# q  `  y
count=0
# i0 x* n9 |5 b( a. q/ P1 Vwhile count<100 :
9 {/ t1 p; Z6 \% j4 T0 C& }    if count %2 != 0 :
' v. J) f6 T! f! Q* _        print(count)
    count += 1
! T0 b0 w# x# C' @5 ]2 `# V
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)

" T: m) Y1 `8 Jcount=0
while count<100 :
    if count%2 == 0 :
4 v! G3 j8 g" A5 u! O        print(count)
    count+=1

$ ^4 K8 f; b/ A8 D2 L+ m# m12、分别书写数字 5，10，32，7 的二进制表示
$ p0 e2 {0 Z% u) k5 l! A
% O* F1 w# L& ?' g2 Kprint(bin(5))二进制   0b101
  @1 L- c, Q1 y6 p# j) S7 i4 W6 mprint(hex(10))十六进制  0x5
- g1 v1 \! w9 [+ Kprint(oct(5))  八进制  0o5
8 S2 C6 \& A: e* B- o14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

, m9 t- Q* C, ]* x2 h. s1 \- q16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
  |- f4 X( {, k$ G0 _% O3 I17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
5 u2 [6 V& M. m2 a) ^: j  O4 ha. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
; J, A. B: X1 ]; k6 H! w! xprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
1 M% L8 e0 q7 F. V4 E& yd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
3 U! Y$ f: y: E6 ?' K5 y+ qe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
" n* ]1 w  Y- s7 g4 {4 ?7 ~
% w: P$ D2 K- S% ?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'))
! h4 N# Z  ]! V! Y' K+ f. M7 d# A21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
+ F9 _7 _& |% s, {    print(name)
* r2 B3 R0 C. R% jfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
* @9 |0 M5 H8 D/ Y& C. a" F22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
" t. ?3 K/ i2 F ['alex', 'eric', 'rain', 'seven']
, g7 v) k7 ^' X& Z( [c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# B  M( p5 T$ _- }5 R0 dprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
# x# m2 g2 m4 k; n, i* b2 t/ t7 r/ [0 Ie. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# _2 S# N2 P: e3 s6 I, q" kli.pop(1)
( W; g7 ^( D. A8 |4 U  dprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
2 n4 ?6 O) U  F8 W+ A2 ~1 {
( \0 P' L4 A3 h6 O$ Teric
' Q/ e7 H5 }9 u- J['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
( T: L3 P: V! r) R* T' bfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
2 U7 _7 a1 v# d; T+ Kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
/ E# |  U. k  g6 `24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
6 E  ]+ B! A' e! ^# ob. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
, T  C3 J( M0 W- u6 g+ v- `$ ofor i in range(len(tu)) :
, f0 G1 W7 K7 l3 ]9 B* e9 z    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
# X! m. Y" m0 H; A: o% gfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
0 e3 k9 G9 B0 P5 C2 h! o(10, 'alex')
+ c& F% ]! z: B' Y8 k8 S$ f(11, 'eric')
(12, 'rain')
% A8 Z- v; B; {
* i, y2 A; T5 z) m' X0 ?, C
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

- j; \, @9 M7 A7 cd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

& y8 ~) G2 ~5 r% r! nprint(tu)
* c7 n2 ]% \- Y* ~- {+ V26、字典
/ g% O* o0 H  y9 T, kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
) u' K; F5 ?6 C9 Yprint(i,dic)
! M& E5 ]0 i. dd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
+ ]4 Z. x& s4 S5 X9 ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
' @) K: R( F8 q* Ldic['k1']='alex'
' o% M" j; v6 ^/ |print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 ?. a0 H* C% C, adic['k3'].append(44)
' V- y2 [- Z7 `' ?( Cprint(dic)
- b0 U: |! k( e$ X# x1 r; r- a
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
# ^, d" k. N3 m6 y2 F/ Kprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
5 `) F' S" S! B
3 X7 u! R! ?3 R3 W  Hprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
, u1 t3 h1 J1 S. _) I8 v( T% f
% w  h: |3 p; b* ]b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
. _/ k" j& f% }, [; V( Iprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 U5 h. J6 v; c9 P. I( X. ?tu = ('Alex', "seven")
li=list(tu)
, J0 Z& N. N7 g8 l. Aprint(li)

% Q* r* R# P$ E! q5 G: E, r
7 P- D5 _  E% Q! ?. j+ M5 yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
$ c# @) O; T0 ~$ e
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" ^" B# U% @* I8 X4 H+ y    dic[k]=v
8 X; m* l7 U0 i    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
1 e6 z3 n+ D" \- ]8 vprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
6 L  K( \( z6 ^! |4 Nb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
6 H+ o6 [" X+ p+ ?3 I& esum=0
+ q  X  D5 n. ffor i in range(100) :
6 O: }. z4 \1 R% t. h" R6 b% z+ x    sum=sum+count
: [! o5 ]; |3 _0 P3 m) Q    count+=1
print(sum)

count=1
8 l0 D7 ]1 A0 T4 N0 k$ _0 ~0 Bsum=0
while count<=100 :
    sum+=count
7 ~- Q- o% E6 V/ v( {5 P$ I- A    count+=1
print(sum)29、元素分类
9 H* ~# k! t3 b3 h. k* J有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 w* [8 g3 M/ L7 Z+ S  _4 I将小于 66 的值保存至第二个 key 的值中。
" M1 w7 g! K& M/ q: l即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- F. B! \+ d' Z' v+ ]3 z* k) h- Qli=[11,22,33,44,55,66,77,88,99,90]
dic1={
4 K9 F% W! `  I; b    'max':[],
- _; R1 \/ \# x! o    'min':[]
}
/ A6 n7 k6 p' @/ l( S; y% Sfor i in li :
  Q6 `- Q& n* f% c& ]    if i <66 :
        dic1['min'].append(i)
7 T6 Y, m) ~( l2 d6 S- h/ N2 H/ G, m+ [    else:
& F. A! E5 e& W" U3 J2 _2 k        dic1['max'].append(i)
7 V) m: A% D! D# c3 _print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
/ g. g0 a* _+ E- R