【Python实践系列】Python学习与实践（一）

- 日理万妓 2022-06-07 10:20 256阅读 0赞

# 热门系列： #

*  #   [程序人生，精彩抢先看][Link 1] #

--------------------

## **特别注意:python代码编辑时：后的执行代码必须在四个空格缩进符后.** ##

> 1.下载python，创建开发环境。

> 2.下载完毕，cmd输入python，检测环境是否搭建成功。

> 3.使用python运行助手，下载learning.py文件，在cmd输入python learning.py运行并不关闭。然后在浏览器输入local.liaoxuefeng.com:39093，则进入在线编辑器。

> 4.使用print()函数输出，使用input()函数输入，可以达到交互式编辑，如：name=input("Please enter your name!") 回车输入一个字符串名称，即可使用print("hello,",name) 输出刚才的名称。

> 5.ASCII编码是一个字节（8bit）；Unicode是2个字节；UTF-8是1-6字节，字符数字一般1字节，汉字3字节，其他生僻字符4-6字节。电脑内存一般都是使用unicode将数据放入内存，比如用笔记本编辑时，当编辑完后，保存时则是以UTF-8格式保存数据到硬盘。

> 6.python通过ord（）函数获取字符整数，如：ord（'中'）；通过chr（）函数通过传入整数获取对应字符，如：chr（4564）。

> 7.使用编辑器编写代码时通常会加入以下两句注释：
> 
> \#!/usr/bin/env python3 这句是为了在linux等操作系统中让解释器知道这是一个python可执行程序。\# -\*- coding: utf-8 -\*- 这句是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
> 
>

> **8.python占位符**
> 
> <table style="width:0px;"> 
>  <tbody> 
>   <tr> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       %d 
>     </div> </td> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       整数 
>     </div> </td> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       %f&nbsp; 
>     </div> </td> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       浮点数 
>     </div> </td> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       %s 
>     </div> </td> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       字符串 
>     </div> </td> 
>   </tr> 
>   <tr> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       %x 
>     </div> </td> 
>    <td style="border-color:#a7a7a7;vertical-align:top;"> 
>     <div>
>       十六进制整数 
>     </div> </td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> 如：“hello，%s” %"Demo"，则会打印出hello，Demo；有几个占位符，%后面就可以用括号跟几个参数；浮点占位符可以控制浮点后小数位数，如:"%.2f" %"3.1415926" 则输出的是3.14

> **9.python集合list**（个人觉得类似java中的数组）
> 
> 例如: classmates = \['jack','rose','david'\]
> 
> classmates.append('jerry') 在集合末尾添加元素
> 
> classmates.insert(2,'tom') 在指定位置添加元素
> 
> classmates.pop() 删除末位元素；也可以加入参数即下标，删除指定位置元素
> 
>

> **10.python元组tuple**
> 
> 语法定义:demo =('a',b,true,\['xiaoming','dawei'\])
> 
> tuple中的元素不可改变,可以用下标的方式获取对应元素。注：所谓元素不可变，是指每个元素指向不能变，指向list就不能变成其他对象，但list本身所含元素是可以改变的。
> 
> 当tuple只有一个元素的时候，需要加，号，避免与括号所表示的数学算法产生歧义，即demo=（1，）。

> **11.循环 for/while**
> 
> 语法：
> 
> arys=\['jack','rose','tom'\]
> 
> for name in arys:
> 
> print("Hello,",name)
> 
> 语法：
> 
> n = 1while n <= 100: if n > 10: \# 当n = 11时，条件满足，执行break语句 break \# break语句会结束当前循环 print(n) n = n + 1print('END')
> 
> 也可以使用break跳出循环或使用continue跳过。

> **12.dict和set**
> 
> python的dict是dictionary的缩写，类似于java中的map，已key-value的形式存储数据。
> 
> 可以通过 ‘元素’ in dict的方式来判断是否存在该元素，或用dict.get()函数来判断，若不存在则返回none，而在用户交互界面则不显示。
> 
> dict可以通过pop（key）来删除对应元素，通过dict\[‘key’\]=value的形式来存入数据。但必须注意key是不可变对象。

> **13.python函数**
> 
> 语法为: def 函数名(参数)
> 
> 函数体
> 
> return
> 
> 参数又分为位置参数，默认参数，可变参数和关键字参数。
> 
> ①例如：
> 
> def power(x,n=2)
> 
> s=1
> 
> while n>0:
> 
> n=n-1
> 
> s=s\*x
> 
> return s
> 
> 此处的n就是默认参数，当调用函数power（5）只传一个参数时，则n=2；当为2个参数时如power（5，3），那么此时n则为3。
> 
> 注意：当有必须参数时，必选参数在前，默认参数在后。
> 
> 默认参数必须指向不变对象。
> 
> ②定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个\*号。
> 
> 例如：def calc(\*numbers): sum = 0 for n in numbers: sum = sum + n \* n return sum
> 
> 调用calc（1，2） \#结果为:5
> 
> ③关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
> 
> 例如：def person(name, age, \*\*kw): print('name:', name, 'age:', age, 'other:', kw)
> 
> >>> person('Bob', 35, city='Beijing')输出：name: Bob age: 35 other: \{'city': 'Beijing'\}
> 
> 注意：\*args是可变参数，args接收的是一个tuple；
> 
> \*\*kw是关键字参数，kw接收的是一个dict。
> 
> 使用\*args和\*\*kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

> **14.切片操作**
> 
> temp = list(range(100))
> 
> print(temp\[0:3\])
> 
> print(temp\[::5\])

> **15.迭代操作**
> 
> from collections import Iterable
> 
> isinstance('AVC',Iterable)

> **16.列表生成式**
> 
> 例如生成\[1\*1,2\*2,3\*3,4\*4.....\]的列表
> 
> team = list(range(1,101))
> 
> ary = list(x\*x for x in team)
> 
> print(ary)

> **17.双重循环排列**
> 
> team\_one = \['A','B','C'\]
> 
> team\_two = \['D','E','F'\]
> 
> ary = list(a+b for a in team\_one for b in team\_two)
> 
> print(ary)

> **18.\# 斐波拉契数列**(除了前两位数，数列中任意一个数字都可以由前两位相加得到)
> 
> def demo(max):
> 
> n=0
> 
> a=0
> 
> b=1
> 
> while n< max:
> 
> print(b)
> 
> \# a,b = b,a+b
> 
> temp = a
> 
> a= b
> 
> b= temp+a
> 
> n=n+1
> 
> return "END"
> 
>  
> 
> demo(6)

> **19.杨辉三角** 用generator生成器
> 
> \# 1
> 
> \# 1 1
> 
> \# 1 2 1
> 
> \# 1 3 3 1
> 
> \# 1 4 6 4 1
> 
> \# 1 5 10 10 5 1
> 
>  
> 
> def gener(raw):
> 
> n,a=1,\[1\]
> 
> while n<=raw:
> 
> yield(a)
> 
> b = a\[:\]
> 
> for i in range(n-1):
> 
> a\[i+1\] = b\[i\]+b\[i+1\]
> 
> n+=1
> 
> a.append(1)
> 
>  
> 
> for num in gener(10):
> 
> print(num)

> **20.高阶函数**（简单来说当一个函数a做为参数传入另一个函数b时，那么函数b就是一个高阶函数）
> 
> ①map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回.
> 
> 例如：def demo（x）：
> 
> return x\*x
> 
> ls = \[1，2，3，4，5，6，7，8，9\]
> 
> r = map（demo，ls）
> 
> list（r）
> 
>  
> 
> ②reduce把一个函数作用在一个序列\[x1, x2, x3, ...\]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算.
> 
> 例如：from functools import reduce
> 
> r = \[1,3,5,7,0\]
> 
> def sum(x,y):
> 
> return x+y
> 
> s = reduce(sum,r)
> 
> 得到的结果为13570 。
> 
>  
> 
> ③filter()和map()类似，也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
> 
> 例如：def filt():
> 
> return n%2 == 1
> 
> filter(filt,\[1,2,3,4,5,6,7,8,9\])，结果为\[1，3，5，7，9\]
> 
> 例如：把一个序列中的空字符串删掉，可以这么写：
> 
> def not\_empty(s): return s and s.strip()list(filter(not\_empty, \['A', '', 'B', None, 'C', ' '\]))\# 结果: \['A', 'B', 'C'\]
> 
> 注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
> 
>  
> 
> ④排序：sorted()函数
> 
> 例如：数字排序 sort（\[2,9,1,3,0,7\]） \#结果:\[0,1,2,3,7,9\]
> 
> 例如：字符串排序 sorted(\['bob', 'about', 'Zoo', 'Credit'\]) \#结果：\['Credit', 'Zoo', 'about', 'bob'\] ，我们给sorted传入key函数，即可实现忽略大小写的排序，如sorted(\['bob', 'about', 'Zoo', 'Credit'\], key=str.lower) \#结果：\['about', 'bob', 'Credit', 'Zoo'\] ，加入 reverse=True即可反向排序。

> **21.闭包**
> 
> 当一个函数做为其外部函数的返回值时，并引用其外部函数定义的变量。这种程序结构即可称之为闭包。
> 
> 例如：
> 
> def lazy\_sum():
> 
> n = 1
> 
> def count():
> 
> s = n\*2
> 
> return s
> 
> return count
> 
> 上面的函数体即可成为闭包。但需要注意，在执行lazy\_sum（）函数时，返回是函数count，并且此函数并没有立即执行，是在调用返回函数时才执行，如f = lazy\_sum（），当使用f（）才回执行返回函数。
> 
> 特别注意:返回闭包时，返回函数不要引用任何循环变量，或者后续会发生变化的变量。
> 
> 例如：
> 
> def outfunc():
> 
> L = \[\]
> 
> for i in range(1，4):
> 
> def infunc():
> 
> return i\*i
> 
> L.append(infunc)
> 
> return L
> 
> L中存在的是3个闭包（此处用f1，f2，f3表示），在执行f1（），f2（），f3（）后可能觉得结果是1，4，9，但结果却都是9。这就是因为返回的闭包并没有立即执行，而是在外部函数执行完后，才执行，而此时循环变量i值已经为3了。

> **22.匿名函数**
> 
> 关键字lambda表示匿名函数，冒号前面的x表示函数参数。
> 
> 例如：list(map(lambda x: x \* x, \[1, 2, 3, 4, 5, 6, 7, 8, 9\]))，同样，也可以把匿名函数作为返回值返回，比如：def build(x, y): return lambda: x \* x + y \* y

> **23.偏函数**
> 
> functools.partial就是帮助我们创建一个偏函数的，作用就是把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
> 
> 例如：
> 
> int（"1000",base=16） 就可以把字符串1000用十六进制转换成对应的整数。但如果需要转换的比较多就比较麻烦。我们就可以用偏函数来通过固定一些参数创建一个新的函数，如下：int2 = functools.partial(int, base=2),这样用int2（"1000"）就默认转成二进制的整数了。当然也可以继续传入多个参数，如int2（"10000",base=10），返回的还是十进制的10000。

记录学习也是分享.....

> ### 本博客皆为学习、分享、探讨为本，欢迎各位朋友评论、点赞、收藏、关注，一起加油！ ###

![20201029165124734.gif][]

[Link 1]: https://blog.csdn.net/yy339452689/article/details/109314083
[20201029165124734.gif]: /images/20220607/1262e48e8ab84d0ebc475d5758c2897b.png