Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

( v: o- G3 M  w$ y+ @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

  q# U& N/ O1 _# `5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

% ^# n% ~# u: `( [6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

  W7 H8 N4 h3 G( ?6 G3 T8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
0 l  v5 v4 Z# c0 Vpwd=input('pwd：').strip()
# p: D4 X7 l! `) iif name=='seven' and pwd=='123' :
4 b& }" p: P2 Z+ P0 c2 e    print('ok')
else:
, d! @' g. J! K3 ?5 x5 j7 v- L    print('error')

( ~6 U$ Z  |9 p, R! a" o. nb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
$ M. |4 x& Y3 u: ^  {; @! Qcount=1
7 \  ^7 W; ?2 V. [: zwhile count<=3 :
    name = input('name:').strip()
' N6 n) y7 x1 j    pwd = input('pwd：').strip()
, z) s  t9 G4 A8 v1 v$ O: ^; B
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
9 u" |( ~* g( Q5 Q        print('error')
. ]+ Q$ f" [5 O        count += 1
for循环：
& L' Y- c+ _3 `' K  [. jfor count in range(3) :
# r. n- n! }& V4 Q& r( A/ l6 V    name = input('name:').strip()
# l/ J$ ^4 Q/ z5 G    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
! D" Q! N6 d/ s; |# D. Y        print('ok')
* @- ?, U) p) G5 U1 ]    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
* O, b& e' q* y; o6 \* x    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 T6 K, L  L: K+ i; P* f: a9 K2 @        print('ok')
# M3 b- z/ E, m8 F# r$ `: a    else :
* L/ K8 s5 v. h) }+ e        print('error')
7 T; l  C0 M5 |$ c' ^        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
6 G6 \: c3 X- o- Z) U4 }    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
$ Q, Z- [- @& s% W& Snum=0
& V  k4 m  C7 \, W  T6 |while count<=100 :
0 w% `6 w( s& N' w) d+ I. Z    if count % 2 ==0 :
        num=count+num
        count+=1
" ]1 _2 ~: N- [- N, K' y0 P    else:
        num=num-count
6 H; l! d" c  ?. A; @+ H        count+=1
print(num)

1 z( j: e* h) v; Bb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
& V, A( ^* \; W% P& M$ {count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
$ c: J' U. B. C  q4 w- i1 g+ u    else :
        num=num+count
) m) I4 x) ^8 V& [print(num)

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

count=1
  d; d' ~  a" l5 R. }while count < 13 :
1 R) l! S/ ~& j/ {* Q& C    if count !=6 :
' _# ~& p! Q$ @9 ?6 Y7 \; I- h        if count !=10 :
+ t' \) `/ `4 ?  r& c            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
0 ?! k6 A  C! P& y+ W    if i %2 != 0 :
        print(i)

count=0
while count<100 :
6 {6 L, f$ P3 c/ B+ C  Z9 ^    if count %2 != 0 :
        print(count)
6 v5 S( O. K4 u5 q! p3 d    count += 1

: z$ {7 z* H$ x5 A$ `* H+ R: Me. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)

count=0
$ `1 d( {% g) P0 _- C5 |1 Lwhile count<100 :
    if count%2 == 0 :
  U5 D$ s3 t: C% f3 V4 }        print(count)
    count+=1

$ E& {. k# [) m3 k+ V' ~' a12、分别书写数字 5，10，32，7 的二进制表示
' h9 G2 f2 b$ y0 c+ m: R; c  E7 p4 A
print(bin(5))二进制   0b101
0 H9 C9 _. D: f/ {$ p+ E  dprint(hex(10))十六进制  0x5
" q, R) k- Z& w5 a2 wprint(oct(5))  八进制  0o5
1 O5 q* }  m- c0 [5 |- B14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
4 U/ {& l8 T0 c4 n5 Q0 N; U17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
- J/ L1 x# q8 m9 xprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

3 n8 e1 n2 I, ~20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
, g1 |: [% N- B7 D: G/ ]1 L- L" \a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
  k3 u% @( ^* Z. ?) L
% O- o& X: a7 q: d& R# m; w) ^b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, D6 v. M: F. Y/ bd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
/ z& B% b2 X6 \# d) we. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

+ n$ a2 S" R  z! \' xg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

5 q+ R0 ~3 Q  a! K( @5 uj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
. Y0 h: P  ~- {' ?4 Z21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
' K3 G  R' ?. q* @name = "Alex  "
for i in range(len(name)) :
* Y/ s' ~; Y! [- X$ d* J    print(name)
for i in name:
7 g! Z0 Q% L% ]7 i    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
9 |. `1 g4 }, k( E9 a. l. d22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
) a; X: W4 y. v$ S  g, ~print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
7 ?! Y2 E: b6 I% J& c; t ['alex', 'eric', 'rain', 'seven']
3 A9 k: j; F/ M0 \) jc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
3 ~/ r9 T' h4 yprint(li)    ['alex', 'rain']
/ q: i6 U0 B3 `1 I& l# _指名道姓的删除li = ['alex', 'eric', 'rain']
* t) {( z! s( ?( Oli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
4 }4 Y( s: O) Lprint(li)

eric
( k' f" @0 X$ U['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
; L. L3 B) i& V! Idel li[1:]
* s/ P( g$ s2 r6 w# dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
% o0 ]# g5 `4 Y/ Y2 |7 l) Ifor k,v in enumerate(li,1):
, C2 }6 w* s' j: k( ?    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ _% I1 _6 O3 e4 u/ Yprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
: g8 _! F$ C; Q3 v* cprint(li)
3 Q) ?! o7 G2 J2 A24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
% ]( x2 n% M2 N1 Rprint(len(tu))
0 D; i7 G: n5 ~# B' q7 Yb. 获取元组的第 2 个元素，并输出
4 ~' S2 h7 o' l& M8 X6 bprint(tu[1])
" A6 @- q6 y1 j8 u+ o: [e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
: Y; u: n) M9 i/ P# W" v    print(k,v)
10 alex
11 eric
& V$ X' }; a  K$ i% w12 rain
* o) ^9 c" ~; \4 e
for k in enumerate(tu,10) :
- H# [& g- x: o% w$ K2 o3 L    print(k)
(10, 'alex')
4 s7 `) |$ t  U; Z(11, 'eric')
(12, 'rain')
' W' L% c! d$ Z$ |- r  f( `% ^9 s" c
: O% [+ g) k7 B9 E) `
: `/ B3 j  {0 P0 I# ^5 p25、有如下变量，请实现要求的功能
7 i1 M. @# \  K, ]tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 V. e  v% W1 t6 w5 c6 {3 ]" Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 h: {% N1 H* m8 u8 Jres=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
+ _; M1 ^  e% C% \for i in dic:
    print(dic)
+ t' Y8 U3 y" gc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
; S5 d/ T7 f1 V  Md. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
3 f/ e; ?( s8 Q- Eprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
6 v, Q* f0 @3 n& V$ \7 {& {dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* b% Y+ G5 z0 M4 zdic['k3'].append(44)
print(dic)

/ \7 k1 i# u& h$ y: }2 M1 f  ~g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
) d) h8 W2 |$ U- _9 }# ldic['k3'].insert(0,44)
  ~3 p+ D9 z  _+ y# zprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

$ j2 {* _% `0 T' Gprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
2 o9 Q' b( [% y/ U9 Q1 Rprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
4 G0 _1 b* m* Y5 {4 T9 Qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% L% q; R# i, P" K, v( Ptu = ('Alex', "seven")
li=list(tu)
: _0 q/ k" ?5 @) B9 |print(li)
% L1 i. H9 j1 {* D+ \

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

dic={}
  m& @; E9 w5 p! v$ Efor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
' d( h" d+ z8 ~& D7 ~    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
- _6 B4 p8 X1 E# D* qb=a.decode('utf-8')
print(b)
  O# D1 c6 L+ N, U" Nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) o' o4 I* T  L6 A& k1 _# J" i9 kprint(a)
b=a.decode('gbk')
$ q4 Y$ f8 J& j  f  ?print(b)28、求 1-100 内的所有数的和
count=1
sum=0
  ?6 m: Z6 P* C5 ~7 j. b) ufor i in range(100) :
. @! e: A; }8 L4 t, v    sum=sum+count
    count+=1
1 a) o7 f% F# q% H" l' c) Iprint(sum)
( N% I. j) t5 c  v
count=1
% G, T" [/ C& M, Fsum=0
while count<=100 :
, L' {/ N7 \  K9 W* p: F    sum+=count
# l+ {1 L# P% ^6 l$ _    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
) N8 [( r2 Y6 Z, D+ U! F! k即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
3 C7 I% g- Q$ Nli=[11,22,33,44,55,66,77,88,99,90]
dic1={
& h, f6 E1 H  Y2 F+ V    'max':[],
3 U9 \2 o' D* ^2 l; f8 K    'min':[]
3 r  W' j, R, F}
; [+ @2 _% t- w5 x. @  \' wfor i in li :
4 w  ^- Y$ b' U2 p3 g' u$ T    if i <66 :
: m9 l. @6 Q0 ^# I        dic1['min'].append(i)
    else:
: j- b. v9 X/ {- p' T: C# A  u        dic1['max'].append(i)
! o. p- e/ o4 \9 W+ ^3 w! Xprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( G/ T$ F3 i3 @) N