Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

# c6 I) i  [5 d7 @, S! v3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

8 o+ l! @- h+ v% ^( u6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

4 K& E7 i# s/ T% W. r  t5 }8、如何查看变量在内存中的地址?
0 v) i7 D7 ]/ {- m7 lz=1
1 D6 D/ T/ {+ l, p, G, oprint(id(z))
' G& O  d6 J1 V9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

9 p* Y2 n& J5 |- v; q1 H10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
# u& b! I4 Z6 \& A. m5 v, G    print('ok')
else:
    print('error')
, m; l, J. b1 n4 O9 R
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
4 R* M5 ?5 I) e' f4 H2 u0 o2 Hwhile count<=3 :
+ a: A5 t5 I( u4 [9 a  q1 _    name = input('name:').strip()
    pwd = input('pwd：').strip()
- O/ P$ |% M+ k1 V/ P
3 {1 w- T/ \5 ]0 b5 s" r    if name=='seven' and pwd=='123' :
; _9 y4 h) h  s6 H5 z" c* [        print('ok')
    else:
# u. i! X+ O7 I/ n3 C        print('error')
        count += 1
for循环：
4 _- x* A1 S5 Ofor count in range(3) :
4 C( d$ M3 Y2 M& J$ e+ k    name = input('name:').strip()
, u0 }+ ^( o  ]* R( w8 T9 R" D    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
1 T6 \, w. G5 ^' J    else:
        print('error')
. v& i6 T* t4 c3 p3 K3 C1 v5 w        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
3 C0 K" j& ^2 A* _: }. E! Gcount =1
while count<=3 :
    name = input('name: ')
  g' Z. t# ]. T! s0 g* b    pwd = input('pwd: ')
" h0 c1 @2 f; b4 n3 W1 N    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
/ _; }- {9 V  O5 V& j    else :
        print('error')
4 h" V2 t, d8 p/ J$ F$ }' d        count+=1
& D1 `% ?; z, q* f1 G+ P; Nfor循环
for count in range(3)  :
* f5 [, _* A: k+ j- U    name = input('name: ')
    pwd = input('pwd: ')
& @& R' F2 L9 q    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
" s& J5 c+ P' V( g        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
0 e. ~2 ?. a! u& v" Rcount=2
num=0
2 `  n7 a: `( ?! {' O& s$ A/ Mwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
" ~8 S& X9 U- F5 W) P        count+=1
8 j' p- ]: ^. z% k& n$ m* Z    else:
        num=num-count
% S. ^& g7 i: O& E3 f0 f        count+=1
  q# A$ u7 E4 f. O% Cprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
% j% s3 `: b5 w; n$ s( J num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
& [5 u/ d( l+ `' G9 P        num=num - count
    else :
$ X: y- u0 r/ c" s' M1 E* D% z        num=num+count
- u! b% k  E( M0 x; p9 gprint(num)

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

count=1
6 X9 b  c+ s5 r  v; xwhile count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
" p, G8 N9 |- e
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
3 c+ p0 y6 m9 Cfor i in range(101) :
    if i %2 != 0 :
$ ~; q7 f4 p7 F7 {        print(i)
$ f2 |" ~4 K4 T1 z+ C
count=0
while count<100 :
# X6 M) g2 x% [$ R. {- Y    if count %2 != 0 :
        print(count)
    count += 1

  P( ^) z( ^+ ge. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
3 n, x5 M& A$ s2 g4 e; Q
count=0
while count<100 :
    if count%2 == 0 :
        print(count)
    count+=1

% O0 B/ v: `- D- j12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
& w) X  D& I: i& o* T8 Kprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
4 j: c, l: M' y% z, c17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

& m! Z9 q/ d8 T$ [
4 J5 n- @& j- |# Z% R) w18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
) |, W& h* w! c& y' Q4 I( Da. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
3 ^: s$ k" ]6 r, y. g2 j8 B; |d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
6 F- K. ]2 M6 yprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
1 G6 b2 ?! C# d# s$ }: \
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

5 k' X6 d/ S+ X& y& E: xj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
" D- g& ^( |" a3 i$ K! z* z    print(name)
for i in name:
4 f- R  |7 w$ Z* s    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
8 F$ E9 ?; I3 D+ y22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
7 O( N0 H* k5 {: E  x; i$ p. eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
% B: `* y7 v( f$ E ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 P- C$ D- e5 sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 A- y" G4 M6 W# A2 Nprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: F2 Y" _2 k' P! Cli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
' g" ~$ O8 G/ B; dli.remove('alex')
print(li)
; k  ~, @) a- F2 P( l9 [0 h  ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
  e* r4 v$ y7 `7 m1 ]; b- I
5 E( K4 k$ h. J3 |* V1 V8 peric
/ m: v# @, h9 i0 X['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
7 G8 J  B" j: @/ i- sdel 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]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
" a. T0 e; ]& J& P% A6 g0 x  @& \b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: E" M+ R' z; ~, @li[2][2]='ALL'
2 w4 d6 s, ~5 Kprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
+ u8 M; t# p$ T, Ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
6 G1 N7 Z5 V# d& xprint(len(tu))
1 r9 e: Q; A5 {" R2 Y0 m7 ~b. 获取元组的第 2 个元素，并输出
, \" v3 p; g% [; a# p) mprint(tu[1])
7 Y3 D' Z. Y* F7 n. qe. 请使用 for、len、range 输出元组的索引
3 r  j2 |# d- ?+ D8 N- f% Cfor i in range(len(tu)) :
" B6 t  I3 @2 ^: g    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
$ w' e  d' g, t4 c& C& R. ]for k,v in enumerate(tu,10) :
6 z$ f2 [$ R) a: r) \    print(k,v)
: A, M; a6 D: R- X. l2 {10 alex
) n& z9 G% R  U- J+ P11 eric
12 rain
) l2 }# R$ ~9 O$ K( @6 }$ {# O. L$ h
! t/ S% f( L# {7 Z. `for k in enumerate(tu,10) :
0 Z# D& \2 |0 \% m! b! ^. N    print(k)
5 h4 u3 o6 O- S, c* u: w6 F(10, 'alex')
# m8 y8 s3 M6 x(11, 'eric')
% C7 O$ U% m: y* ~9 o! a' g(12, 'rain')

4 }, u; j4 q3 J; t" @7 N; F
3 U' F0 F. x. L& X" E6 s$ }25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

4 m  u# j2 M' ?4 [4 Jd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" @& H) S! x" [+ T; [' h: xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 a* h; Y% X* Z. w  Zres=tu[1][2]['k2'].append('seven')
, q& |8 n. Z& I. J
+ G' b6 q' W1 n) |4 ]3 Yprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
" s0 u* S  t, ^, {8 y9 a    print(i)b. 请循环输出所有的 value
1 T+ @8 |# |7 F( ~* z6 K( A8 Sfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
4 e9 U- B7 _0 ?* B9 U5 G' fprint(i,dic)
& n$ k& j9 d* M" r* L4 Dd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
) o3 A6 K/ F" o7 _dic['k3'].append(44)
. H) P" m, Z# O* K! X: Y* l: ]print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
+ L* y: }7 \: ^a. 将字符串 s = "alex" 转换成列表  s = "alex"

1 ~3 E& J5 t  O; P: n$ Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
) s. p( I$ r" J( b1 is = "alex"
3 \- m7 Y# B' R) X6 A* Tprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
7 d0 N( E" V- X, d* [. P- H8 Cli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
! i4 R" x" W4 sli=list(tu)
print(li)
5 o1 O# j/ ~0 L/ L
! n* I) l$ `) N( F: R  j4 O
& G. t7 T0 r  w8 N% {& K' A* Yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
( I2 {* J/ `* I. q6 p6 v4 Z8 V
4 F* C! o- `3 r' C1 x/ \& D0 _( Cdic={}
- `' d7 m; g; K4 Ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; @9 X) ^$ G0 R' N; Sa=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
- P# l9 a2 ?; {( Zprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
# Q' @. A, J' u. |" I% l7 t, qb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
' n) f, j& s3 ~1 w' V. jcount=1
3 @" D* T0 Q; t  Y' Gsum=0
for i in range(100) :
- p; i- M2 V4 P    sum=sum+count
    count+=1
print(sum)
2 Y8 }4 e" s: [0 ^8 Z# ~7 U
count=1
0 O/ H! u# C  Z3 `' u0 k; msum=0
while count<=100 :
$ c" s$ Z! j& Q    sum+=count
; c& ~( T' X9 ]0 Z4 ?& t& J7 V$ t7 h    count+=1
print(sum)29、元素分类
  H' M( D/ z; J& ]有如下值集合 [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]
& [" n7 g+ s" T" k8 Fdic1={
    'max':[],
    'min':[]
, T5 Y( j- g8 Z+ s9 A7 P}
for i in li :
    if i <66 :
        dic1['min'].append(i)
    else:
9 g4 L+ E$ U8 M/ F. u: l        dic1['max'].append(i)
print(dic1)
; M& ~, j$ A# _! i7 M7 H6 @, a
0 h+ g- ^; d! }$ n6 l& u) [+ s---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
+ n% R! E, Q& T! n6 z/ r- A