Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

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

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

单行注释 #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

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

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

10、写代码  D7 O  N, a, C4 C9 k. p
a.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :
8 ?8 O1 K) W5 h' E name = input('name:').strip()+ ]4 w5 w/ W: N# E  i
pwd = input('pwd：').strip()0 z. c. r/ M) K

9 M; X2 G, @4 [2 C if name=='seven' and pwd=='123' :! T, L- Z, o; P# J9 N: `, ]
      print('ok')/ |, G# [* i2 c" M% P$ r; P$ t
else:
! R  n$ N5 `. k5 @' _( r. D       print('error')
* c  e! p4 z$ n( E3 }       count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :6 }9 B3 ?) E9 u! V
name = input('name: ')
1 B# C& }: s; y* C+ \  z: n pwd = input('pwd: '). O+ P; A% j8 p% a
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 H. T+ }3 X) m  {# B1 x2 h       print('ok'); T9 t$ |( _$ O7 H
else :
8 S- {. B* j* h4 B+ V       print('error')
/ S% {3 t8 d+ t. I       count+=111、写代码4 n: x% m' |* _/ q! P
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

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

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
  d$ I' e7 l! l. A' w$ O* C if i %2 != 0 :4 {/ q5 D+ t( Q  V
      print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :3 r7 W! H, C; l+ u0 b8 e: a
if i %2 == 0:
6 m9 p& y4 y, n6 {       print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

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

print(bin(5))二进制 0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

18、布尔值分别有什么?

False .Ture ,或1 和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"9 {* N! S% O& }
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p')) apex
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e')) ['al', 'x  ']  列表

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'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name), y, z9 Q5 p1 n) D" f
for i in name:
# S6 w6 b1 n/ H0 {. Z. j print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain' {$ x! `6 P- q- C4 k4 W, D
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 h0 v* D, F& _, k+ b# E9 {print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
- f( ~- s3 t* t. f( l( @6 Fprint(li)( f8 r7 K, p) a' u0 A
['alex', 'eric', 'rain', 'seven']
6 r) T8 h9 s( g5 cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')+ r6 J' n: W- M0 z( _* x! v& M
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
4 k/ G+ \# k; v6 ?. xprint(li)
* ^6 S0 Q# p" K4 Re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
5 c4 f0 V* {5 }* |. p% jli.pop(1)
& ^0 y. S) P" O) _4 X' J1 hprint(li) ['alex', 'rain']
8 d7 N! t, T- R指名道姓的删除li = ['alex', 'eric', 'rain']# z) Q5 p, k7 s: {+ @9 O" `7 z
li.remove('alex')" ?9 {6 m, e0 n- w6 J
print(li)2 j5 x) r4 }9 F( C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
4 A. m% w( ]1 H. [% i6 V( Kprint(li.pop(1))
) m& f! g# i, zprint(li)- S& N% L( }0 T5 D1 K/ v. T

# T, R' J0 R: i& teric* \& j* g  v* N' J1 q
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
2 q5 I4 N/ _( i/ t$ Wdel li[1:]
  |! S; f; y- g: Z2 gprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
/ N4 h8 ?! J1 b" m+ M. T' t3 sli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
  P" j8 A% B7 t! h/ k! {4 r print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]( x5 M6 }8 d  o: i
a. 请输出 “Kelly”
! h, k$ t, {9 J% l/ k$ }& `li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]6 D% L9 |$ V7 s' t) @; q
print(li[2][1][1])
" H2 h- p! ?) a+ m: f: [b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
8 P. c& B; J7 |, Kli[2][2]='ALL': e7 D: T  b/ a/ M0 ]2 w
print(li)
# l7 u2 j) z" |! U7 p24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
/ T. s- y8 o* w. K' Y! e9 q0 Xa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')1 F9 s9 T/ Q6 j# Z0 F/ Q
print(len(tu))% y8 Q0 ~7 J: w+ C% d" @
b. 获取元组的第 2 个元素，并输出
: ]2 z" q8 g7 zprint(tu[1]), X$ f+ `5 r" n* v9 ^: Y
e. 请使用 for、len、range 输出元组的索引) b# U* L0 \7 D! j$ V) q
for i in range(len(tu)) :
8 L( r7 j7 j/ M; g print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
  n. R! J4 j5 }( ofor k,v in enumerate(tu,10) :
9 H& ~7 C9 P9 `! p* f7 X9 l# t7 k print(k,v)
, `3 M2 r* i! W/ M; s2 m+ d10 alex9 J* I1 R& y( K; b( o
11 eric
- e# \9 ?( K$ g; \0 E12 rain
0 [2 B+ g2 l: E) ]/ @* O, r& N4 X5 g2 p4 D) ^3 x
for k in enumerate(tu,10) :
( l2 w2 M/ E  j print(k)1 d: c2 U* H# M( g8 c+ c
(10, 'alex')
8 ^7 D* a9 k2 H3 q, m$ @  m(11, 'eric')
# q9 ^, L4 E8 o) s(12, 'rain')8 q2 {' G' H7 K
- C  X) D9 I5 w8 |# u+ z
, s- Y8 n: w2 i4 Q( P5 C. j; m& X
25、有如下变量，请实现要求的功能
5 d; T% h& w. b3 W4 F1 {/ Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

4 h6 l6 J: O3 _- m' ]d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ V6 J0 {& N* g# f8 z* q) ]8 \" E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! r; I$ C$ r0 [& U! U+ [$ u3 C9 x% nres=tu[1][2]['k2'].append('seven')
. b7 T7 U) |! H- b" t' L: ~" |4 S! {8 _) t7 C7 J9 |# r
print(tu)
' c" J  Q0 v& M! B, t26、字典$ q6 u' l7 [  z$ m  r8 V
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
5 s  \0 N% H: N# p, l- w print(i)b. 请循环输出所有的 value
8 R, R0 S* B: o& d6 {$ A- Ffor i in dic:
6 X) C+ m2 Z- m. \ print(dic)' y/ J$ a; v! K, x
c. 请循环输出所有的 key 和 valuefor i in dic:
  s, @3 P8 R7 C- `2 z+ x7 Lprint(i,dic)
5 |( Z' C5 s# Ad. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& ]# W* v) q  T( odic['k4']='v4'
, b8 X* A4 h0 P( W: t% y1 O: V- Fprint(dic)
3 U( M+ @6 O% E* h) X0 @e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典7 j& \+ S9 G! ?
dic['k1']='alex'
2 J% J5 A4 s6 o/ ~+ ?/ S5 Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
" [& H# m. {. A9 Odic['k3'].append(44)2 Y2 G) v$ x# k6 o* O
print(dic)
* J2 F: x+ V/ _7 S: l
$ K. S' z! ~! hg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; ?: ~% d, X, y9 q: t& edic['k3'].insert(0,44); y" n4 l4 }- F/ i5 E
print(dic); \5 m6 v6 U/ x) s7 v4 x
27、转换! L. I# @4 f6 d% C0 H
a. 将字符串 s = "alex" 转换成列表  s = "alex"7 E. [% ^$ _) ]/ [/ u% o) J

. F$ v* }4 }5 m6 O2 |9 ^% oprint(list(s))b. 将字符串 s = "alex" 转换成元祖
( w/ g2 _0 W8 d. |! ]. V4 f4 ys = "alex"
8 M0 s( m' _9 V' z0 j9 r7 Aprint(tuple(s)). U% W6 ~4 \) L# S/ e
) C' }0 h* e: H6 `1 R
b. 将列表 li = ["alex", "seven"] 转换成元组- ?' r/ T1 U" Q
li = ["alex", "seven"]7 t% U8 T0 T9 Y5 F4 G0 j
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; t( {4 i, Q8 S1 rtu = ('Alex', "seven")
: z* L0 f$ |( a& @1 ~li=list(tu)- t  I" V$ ^, }5 Q
print(li); x2 a2 ^  q9 A5 [2 q% \
! _* o/ c$ I3 F3 ]8 V+ e6 z
$ k5 e$ Y% K8 P: P9 M# f; b. a( y6 M9 N
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: D. ?' \. B- R& Q
; f% e0 y* r- `5 n- n( ]4 [; gdic={}
. }9 a9 p! `/ N/ \5 ?for k,v in enumerate(li,10) :----li要放在前面，序号放在后面% Q* t, ?, }6 ^: d; r9 ]
dic[k]=v
' f" q, z! W1 B( Y( B$ X) c4 S print(dic)27、转码n = "老男孩"* }6 ~2 Y& D+ n: ?/ [3 I  @5 B
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"0 \8 w5 l' S+ b+ R
a=n.encode('utf-8')
5 S5 I& c2 Y3 H8 q3 ~# b0 hprint(a)0 s+ U5 S0 E  w& j
b=a.decode('utf-8')
' l  v# E+ j" K5 cprint(b)* E" L2 n$ {+ S7 E) ~
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 ], j( {: ^0 Y: k8 Q
print(a)
8 _! h; }4 R3 U' v' r2 ob=a.decode('gbk')
. F- n& p* l" Oprint(b)28、求 1-100 内的所有数的和; J! _2 G& p8 T: {( z+ }
count=1
1 @8 L; r0 |& j; X' ^sum=0
* |4 }/ o1 r% p) rfor i in range(100) :8 p! t2 m8 M& K6 j
sum=sum+count! E) l" [& v8 o: z" o
count+=1
1 D9 ^0 K& _$ i' m/ a+ Aprint(sum)1 i' j" M4 ]1 A  D7 X+ b2 T8 O

* J% L/ G+ k& q4 S. m" l; U0 `count=1+ o0 V9 H! g# b# R( ?3 r5 @
sum=0
+ L0 i3 _9 ^. }; Rwhile count<=100 :
: D1 m8 ?* Y, K" A, o sum+=count6 i: S: g# x0 v6 o$ ?4 R
count+=1
$ t. g& z; k* Q( Jprint(sum)29、元素分类
& q9 v5 [+ i: f6 ?& T# x* \, N6 A/ p有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: f; ^9 \' c% P1 L% [将小于 66 的值保存至第二个 key 的值中。
4 E( M+ I# v. N' `1 o7 L7 T4 Y即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  N: p3 X( R; ^2 f
li=[11,22,33,44,55,66,77,88,99,90]
) w: }* t5 a  \" odic1={
) K( o1 L* C# A4 D1 P8 X/ Z 'max':[],
2 x9 p! ~* W& B5 G6 t3 }% T 'min':[]. X9 g" {% ?% N
}4 |$ X+ O4 g& {. s, O2 J: I! ~
for i in li :
- E; c1 A# d$ K8 f if i <66 :
6 ^0 G' d, w6 H6 R, q  t       dic1['min'].append(i)
$ @; t+ _( B' ~; B else:5 ?: G/ h/ C) j6 P1 B
      dic1['max'].append(i)3 t/ }9 z; p5 a* k6 c
print(dic1)2 }! u+ ~& M3 @9 k

" m6 D: {8 M5 E7 a+ b---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}* A4 P  f7 a& f4 S

Python基础知识汇总

主题推荐