python3基础学习笔记

时间 2019-12-29

标签 python3 python 基础学习笔记栏目 Python 繁體版

原文原文链接

title: python基础学习笔记
date: 2019-11-16 16:47:01
tags: python
categories: pythonjava

python基础学习导图

python程序基础

程序 = 数据结构 + 算法，因此我用两部分归纳了python程序设计基础的内容。python

数据结构

数据

	可变	不可变
有序	列表	元组、字符串
无序	字典、集合	数值

数据结构指数据的类型，计算机程序能处理各类数据，如数字、网页、音频、文本、视频等等，不一样的数据则须要定义不一样的数据类型。python中能直接处理的数据类型有：整型、浮点型、字符型以及布尔型、复数类型五种。git

整型正则表达式

整型，整数类型，例如一、100、-122一、1213243455...，整型有四种表现形式，分别是：算法

二进制：如 0十、110...，只由1和0组成的数字，用0b或0B开头的数字就是二进制类型。api

八进制：如0O17一、0O732，由三位二进制组成，0o或0O开头的数据就是八进制。数组

十进制：日常的数字如一、二、-121等。数据结构

十六进制：由四位二进制组成，如0x01af,a~f表示10~15，由0x或0X表示。app

由位数不一样又分为int 、short、long等。ide

浮点型

浮点数（float）也就是小数，python的浮点数有两种表现形式：

一是十进制数表示，如：12.21等等

二是用科学计数法表示，如1.32e3,即1.32 * 10^3,虽然结果是整数，但类型是浮点型。

字符串型

字符串字符串是以单引号或双引号括起来的任意文本，好比'hello'和"hello",字符串还有原始字符串表示法、字节字符串表示法、Unicode字符串表示法，并且能够书写成多行的形式（用三个单引号或三个双引号开头，三个单引号或三个双引号结尾）。

布尔类型

布尔值只有True、False两种值，要么是True，要么是False，在Python中，能够直接用True、False表示布尔值（请注意是大写），也能够经过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。

复数类型

import cmath

形如 3 + 2j,和数学上表示同样，只不过虚部是把i换成了j。

python至关于一个计算器，直接输入便可，

>>> (3+2j)*(3+2j)
(5+12j)

变量

变量（variable），在python中，名称只能由字母、数字、下划线组成，且只能由字母开头，变量不能和关键字相同。

python关键字列表：

其实开发者本身能够在python自带IDLE查看关键字列表

keyword.kwlist

字符串

全部的标准序列操做都适用与字符串，如索引、切片、乘法、成员资格检查、长度。最小值、最大值，可是别忘了字符串是不可变的，因此全部的赋值都是非法的。

字符串设置

字符串转义字符

'/'，在字符前加反斜线表示此字符不是特殊字符，是能够读出来的，若是不加程序会认为是特殊字符从而会有不一样的效果。

format字符串格式转换

设置格式的值时，可使用单个的值（如字符串或数字），可以使用元组（若是要设置多个值的格式），还可使用字典。‘%’ 字符串格式运算符，‘%’较format简单，format能够运用于更复杂的格式替换。

下面简单用元组演示：

>>> format = "Hello,%s,my name is %s"
>>> values = ("python","yujian")
>>> format%values
'Hello,python,my name is yujian'

关于如何用format设置格式：

每一个值被替换到字符串中都是替换用‘{}’括起来的元素，要在最终结果中包含‘{}’，则能够用两个花括号表示。

格式替换字段能够设置三部分：

替换字段名

能够向format提供未命名的参数，此参数表示一个字段名，而后在后面格式替换时代表参数值便可替换。如：

>>> "Hello,{name},welcome to {destination} world".format(name="yujian",destination="python")
'Hello,yujian,welcome to python world'

name即字段名，后面赋值字符串‘yujian’替换此字段

若在{}里面是数字即表示索引，如：

>>> "{a}{0}{b}{1}".format(1,2,a=3,b=4)
'3142'

运用此方法要注意必须把索引的值放在前面，否则会引发位置冲突。

转换标志转换

'!'转换标志符

转换标志：跟在‘ ！’号后面的单个字符，当前支持的字符包括r(表示repr，简写‘r’，转义字符)、s(表示str)、a(表示ASCII)。

例如：

>>> "{a!r} {a!s} {a!a}".format(a = "Π")
"'Π' Π '\\u03a0'"

格式说明符

':'冒号表示格式说明符，冒号后面跟单个表达格式符或表达式，能够参照正则表达式。

>>> "This number is {0:b}".format(8)
'This number is 1000'

设置浮点数的格式

设置浮点数默认格式是到小数点后六位，若不是你想要的格式，则能够自行设定宽度和精度。

宽度和精度都是使用整数整定，例如：

整数整定：

>>> "This number is {0:b}".format(8)
'This number is 1000'
>>> "{num:10}".format(num = 3.14)
' 3.14'
>>> "{num:10}".format(num = "python")
'python '

可见，数字和字符串的对齐方式不同。

精度整定:前面加一个小数点便可

>>> import math
>>> print("{num:.2f}".format(num = math.pi))
3.14

符号、对齐和0填充

在整度和精度的值前面添加一个标志，这个标志能够是0、加号、减号、或空格，其中0表示用0来填充数字。

填充0：

>>> "{num:05}".format(num = 3.14)
'03.14'

对齐：

>>> print("{0:<8.2f}\n{0:^8.2f}\n{0:>8.2f}".format(math.pi))
3.14
3.14
3.14

指定字符填充：

>>> "{0:a^15}".format("yujian")
'aaaayujianaaaaa'

说明符“=”

它指定将填充字符放在符号与数字之间，如：

>>> print("{0:8.2f}\n{1:=8.2f}".format(math.pi,-math.pi))
3.14
- 3.14

如图负号和数字分开了

若要加正负号，填充字符放在符号与数字之间加’+‘’-‘

'#'

放在符号说明符和宽度之间，如：

>>> "{:b}".format(32)
'100000'
>>> "{:#b}".format(32)
'0b100000'

如图添加上了二进制信息

字符串经常使用方法

repr 和str

都表达转换成字符串的意思，函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式（若是没有等价的语法，则会发生SyntaxError 异常）

print('1:' + str(123))  
print('2:' + repr(123))  
print('3:' + str('123'))  
print('4:' + repr('123'))

#结果：

1:123  
2:123  
3:123  
4:'123'

发现结果一、2是同样的，4却较3保留了引号，其实形成这种的缘由是str和repr都分别调用的是对象的__str__,__repr__方法，repr保留了符号是其实就是机器识别的语言。

center

方法center()经过在字符串两边添加填充字符，若是不指定默认是空格，如：

>>> print("Hello,YuJian".center(20,' '))
Hello,YuJian

find、index

方法find()经过在字符串中寻找子串，若是找到返回子串第一个字符的索引，不然返回-1，如：

>>> "the sun,the moon and you".find("moon",1,20)
12

如上我寻找到“moon“在第12个字符位置处，查找范围是从从位置1到20，注意位置1是'the的'’t‘位置，但返回的都是在整个字符串中的位置。

方法index()查找指定字串在字符串中出现的位置，若没有则引起ValueError。

如：

>>> "hello world".index("world")
6
>>> "hello world".index("wo")
6
>>> "hello world".index(" ")
5
>>> "hello world".index("w",0,15)
6
>>> "hello world".index("w",1,15)
6
>>> "hello world".index("you",1,15)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found

返回值与find方法同样。

split、join

做用于join相反，用于将字符串拆分为序列，返回的是列表。如：

>>> str = "maybe is she"
>>> print(str.split(' ' ,1))
['maybe', 'is she']
>>> print(str.split(' ' ,2))
['maybe', 'is', 'she']
>>> print(str.split('is' ,1))
['maybe ', ' she']

spite()方法若没有指定分隔符，这默认从一个或多个连续的空白字符（空格、制表符、换行符等进行差分）。

join()方法链接多个字符串，返回经过指定“字符”链接生成的新字符串。如：

>>> str1 = "-"
>>> str2 = \["2019","11","11"\]
>>> print(str1.join(str2))
2019-11-11
>>> print(str.join(str1,str2))
2019-11-11

lower 、upper、title

title() #将每一个单词开头改成大写
lower() #将整个字符串改成小写
upper() #将整个字符串改成大写

例如：

str = "hello,stranger"
print(str.lower())
print(str.upper())
print(str.title())
#结果
hello,stranger
HELLO,STRANGER
Hello,Stranger

strip、istrip、rstrip

strip() #删除字符串先后的空白并返回删除后的结果 lstrip() #删除字符串前面的空白并返回删除后的结果 rstrip() #删除字符串后面的空白并返回删除后的结果

如：

>>> str.strip()
'Hello,  world'
>>> str.lstrip()
'Hello,  world   '
>>> str.rstrip()
'    Hello,  world'
#指定删除哪些字符
>>> str.strip("\*@")
'yujian'
>>> str.strip("\* @")
'yujian'
>>> str.strip("\*or@")
'yujian'
>>> str.strip("\*and@")
'yuji'

replace、translate

replace()方法用指定子串替换字符串中的目标子串

如：

>>> "Hello world".replace("world","yujain",4)
'Hello yujain'
将world替换成了yujian,4表示不超过4次

translate()方法使用指定的映射表对字符串进行替换，不过translate()方法须要手动输入各字符的编码进行替换，因此有了一种更方便的方法maketrans（）来建立映射表，如：

>>> table = str.maketrans('abc','αβγ')
>>> table
{97: 945, 98: 946, 99: 947}

此时映射表已经建立完成，而后就能够较便捷的使用translate()替换了，如：

>>> str = "abscond"
>>> print(str.translate(table))
αβsγond

下面用一段程序来了解其余一些字符串的应用：

def main():
    str1 = 'hello, world!'
    # 经过len函数计算字符串的长度
    print(len(str1))  # 13
    # 得到字符串首字母大写的拷贝
    print(str1.capitalize())  # Hello, world!
    # 得到字符串变大写后的拷贝
    print(str1.upper())  # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 与find相似但找不到子串时会引起异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith('!'))  # True
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50, '*'))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 从字符串中取出指定位置的字符(下标运算)
    print(str2[2])  # c
    # 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 检查字符串是否由数字构成
    print(str2.isdigit())  # False
    # 检查字符串是否以字母构成
    print(str2.isalpha())  # False
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())  # True
    str3 = '  jackfrued@126.com '
    print(str3)
    # 得到字符串修剪左右两侧空格的拷贝
    print(str3.strip())


if __name__ == '__main__':
    main()

列表、元组、字典、集合

列表

建立列表，两种方法，

a: a = []

b: a = list()

list() #list() 方法用于将元组或字符串转换为列表。

列表是能够修改的序列，能够像通常的序列进行增、删、修改、检查成员操做。

append() #追加元组，元组会被当成一个元素添加到列表中，追加列表也是同样，会被当成一个元素若是不想把追加的列表或元组当成一个总体，能够用extend()方法。

PS:也就是说append追加的是一个总体，会把"[]"也加进去，而extend是把里面的元素逐一加进去，元组不能追加，里面的元素是固定了的不能改的

>>> list_a = [1,23,4]
>>> list_b = [2,5]
>>> list_a.extend(list_b)
>>> print(list_a)
[1, 23, 4, 2, 5]
>>> list_a.append(list_b)
>>> list_a
[1, 23, 4, 2, 5, [2, 5]]

del() #删除列表里单个元素或者一列元素，还能够删除变量 insert(number,element) #插入一个或者一段元素，可指定位置 remove() #移除列表匹配到元素的第一项 list.remove(obj) clear() #清空列表

sort() #list.sort( key=None, reverse=False) 默认升序，返回一个列表,sort()返回原列表，sorted()返回新列表。

>>> a = [1,2,3,4,5]
>>> b = [2,3,1,4,0]
>>> b.sort()
>>> b
[0, 1, 2, 3, 4]
>>> c = sorted(a)
>>> c
[1, 2, 3, 4, 5]
>>>

pop() #将列表当成栈使用

PS:pop是惟一既修改列表又返回一个非None值的列表方法

reverse() #将列表中的元素反向存放

def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 计算列表长度(元素个数)
    print(len(list1))
    # 下标(索引)运算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    print(list1[-1])
    print(list1[-3])
    list1[2] = 300
    print(list1)
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    list1 += [1000, 2000]
    print(list1)
    print(len(list1))
    # 删除元素
    list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)


if __name__ == '__main__':
    main()

元组

元组，是不可更改的序列，用（）包括的序列就是元组，元组和列表的建立和内存占比明显前者更优。元组的列表有许多类似的，惟一不一样之处就在于元组不可更改，里面的元素是固定了的。

建立方式：

a = (element1,element2...)

a = turple()

tuple() #Python 元组 tuple() 函数将列表转换为元组

元组和列表的共用方法：

只有一个元素的元组：（1，）必须带逗号

列表和元组均可以用加法和乘法，但只能同类型的

max() 求元组或列表的最大值 min() 求元组或列表的最小值 len() 求元组或列表的长度

index() #用于某个元素出如今列表或元组中的位置 count() #用于统计某个元素在列表中或元组出现的次数

in运算运用于列表、元组是否包含元素

列表封包和序列解包

程序把多个值赋给一个变量时，python会自动把多个值封装成元组，这叫作封包；

程序容许直接将序列（列表或元组）赋给多个变量，此时序列的各元素会依次赋给各个变量，这叫作解包，但序列的元素和变量的元素应该相同。

>>> list_a = [1,2,3]
>>> a,b,c = list_a
>>> print(a,b,c)
1 2 3
#变量前加\*号表示该变量表示一个列表
>>> c,*d = list_a
>>> print(c,d)
1 [2, 3]

集合

set和dict相似，也是一组key的集合，但不存储value。因为key不能重复，因此，在set中，没有重复的key。

要建立一个set，须要提供一个list做为输入集合：

>>> set1 = set([1,2,2,3,3,4,4,5,6,])
>>> set1
{1, 2, 3, 4, 5, 6}
>>> set2 = set([2,3,4,7,8])
>>> set1&set2
{2, 3, 4}
>>> set1|set2
{1, 2, 3, 4, 5, 6, 7, 8}
>>> set1-set2
{1, 5, 6}

Python中的集合跟数学上的集合是一致的，不容许有重复元素，并且能够进行交集、并集、差集等运算,也和数学上的运算一致。

字典

元组能够做为dictionary的key,但列表不能，这是由于字典要求key是不可变的

dict = dict()
dict = {}.fromkeys()
dict = {}

字典的基本用法：经过key访问value值，修改、删除、添加key-value对，以及判断key-value对是否存在

字典的经常使用方法：

clear() #清空全部的key-value对 get() #获取key的value值 update() #用新字典更新原有字典，如有则覆盖无则添加 items()、keys()、values() #分别用于获取全部的key-value值，全部的key值，全部的value值，分别返回 dict_items、dict_keys、dict_values对象。

pop() #获取指定key的value同时这个键-值会从子典中删除。

popitem() #方法用于弹出字典最后一个key-value对，而且封装成元组

setdefalt() #也是根据key来获取value值，但有一点不一样，如若没有它将返回为之设置的默认值。

>>> dict1 = {'sun':20,'liu':21}
#没有 key='deng',则先设置key = 'deng',value=20,而后返回该key的键值
>>> print(dict1.setdefault('deng',20))
20
>>> dict1['xia'] = 21
>>> dict1
{'sun': 20, 'liu': 21, 'deng': 20, 'xia': 21}
#存在key='xia'，则不会修改该value值
>>> dict1.setdefault('xia',23)
21

{}.fromkeys() #设置新字典

运算符

Python支持多种运算符，下表大体按照优先级从高到低的顺序列出了全部的运算符，咱们会陆续使用到它们。

运算符	描述
`[]` `[:]`	下标，切片
`**`	指数
`~` `+` `-`	按位取反, 正负号
`*` `/` `%` `//`	乘，除，模，整除
`+` `-`	加，减
`>>` `<<`	右移，左移
`&`	按位与
`^`	按位异或，按位或
`<=` `<` `>` `>=`	小于等于，小于，大于，大于等于
`==` `!=`	等于，不等于
`is` `is not`	身份运算符
`in` `not in`	成员运算符
`not` `or` `and`	逻辑运算符
`=` `+=` `-=` `=` `/=` `%=` `//=` `*=` `&=` `=` `^=` `>>=` `<<=`	（复合）赋值运算符

注：在实际开发中，若是搞不清楚优先级可使用括号来确保运算的执行顺序。

算法

过程控制

程序控制结构有顺序结构、分支结构以及循环结构，相似于C语言及、java。

顺序

顺序结构很好理解，一行一行运行下去，直达最后为止。

分支

grades = int(input("请输入你的成绩："))

if grades >= 90:
    print("excellent")
elif grades >= 70:
    print("good")
elif grades >= 60:
    print("qualified")
else: 
    print("disqualified")

上面用简单的if分支结构来输出你的成绩等级，共有三条关键语句，if 、elif(else if)，和else语句。

if 语句还有一个亲戚断言即 assert,语句逻辑为

grades = int(input("请输入你的成绩："))  
  
assert grades >= 80  
print("great")  
  
#结果  
请输入你的成绩：60  
Traceback (most recent call last):  
 File "d:\Vscode\My code\blog.py", line 3, in <module>  
 assert grades >= 80  
AssertionError

如上，未为知足成绩大于等于80将引起错误

注意：python语句缩进必须所有相同，通常python习惯缩进四个字符，另外if条件能够是任意类型，当下面的值做为bool类型表达式时，会被认为false类型，各种空值如：False、None、0、""、[]、{}

循环

Python中构造循环结构有两种作法，一种是for-in循环，一种是while循环。

for循环

若是明确的知道循环执行的次数或者是要对一个容器进行迭代（后面会讲到），那么咱们推荐使用for-in循环， for循环专门用于遍历范围、列表、元素和字典等可迭代对象包含的元素。语法格式以下：

for 变量 in 字符串|范围|集合等：
statements

例如咱们要计算1~100的和

sum = 0  
for i in range (1,101):  
 sum += i  
print(sum)

.range()能够用来产生一个不变的数值序列，并且这个序列一般都是用在循环中的，例如： ·range(101),能够用来产生1-100的数 ·range(1,10),能够产生1-9的数 ·range(0,101,2)能够产生1-100的偶数序列，2是步长

while循环

若是要构造不知道具体循环次数的循环结构，咱们推荐使用while循环，while循环经过一个可以产生或转换出bool值的表达式来控制循环，循环条件表达式的值为True循环继续，表达式的值为False循环结束。

while 循环条件：
循环体

举一个简单例子，

name = str(input("input your name:"))
while name == "yujian":
    print("welcome,yujian")
    break
else:
    print("hey,who are you?")

注意：上面的代码中使用了 break关键字来提早终止循环，须要注意的是 break只能终止它所在的那个循环，这一点在使用嵌套的循环结构（下面会讲到）须要引发注意。除了 break以外，还有另外一个关键字是 continue，它能够用来放弃本次循环后续的代码直接让循环进入下一轮。

只有输入正确的名字才能够经过，这就相似于登陆帐户时的情景了。

练习：

一、判断一个数是否是素数( 素数又叫质数（prime number），有无限个。质数定义为在大于1的天然数中，除了1和它自己之外再也不有其余因数 )

num = int(input('please enter a number:'))  
for i in range(2, num):  
    if num % i == 0:  
    print('%d不是素数' % num)  
    break  
else:  
    print('%d是素数' % num)

#或者

from math import sqrt

num = int(input('请输入一个正整数: '))
end = int(sqrt(num))
is_prime = True
for x in range(2, end + 1):
    if num % x == 0:
        is_prime = False
        break
if is_prime and num != 1:
    print('%d是素数' % num)
else:
    print('%d不是素数' % num)
#参照一个大佬的计算量减了一个深度,zan

二、统计素数

a, b = int(input("请输入起点数：")), int(input("请输入终点数:"))
sum = 0
for i in range(a, b+1):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i, end=",")
        sum += 1
print("质素一共有%d个" % sum)

三、打印等腰三角形

#正等腰
lines = int(input("请输入行数 ： "))
for i in range(lines):
    for j in range(lines - i):
        print(end=" ")
    print("\*" \* (2\*i+1))
    print()
'''请输入行数 ： 5
     *

    ***

   *****

  *******

 *********'''

#倒等腰
lines = int(input("请输入行数 ： "))
for i in range(lines):
    for j in range(i):
        print(end=" ")
    print("*" * ((lines - i) * 2 - 1))
    print()
'''
请输入行数 ： 5
*********

 *******

  *****

   ***

    *
'''

四、打印菱形

#实心菱形
lines = int(input("请输入奇数行： "))
half_lines = lines // 2 + 1

#上半部分
for i in range(half_lines):
    print(" "*(half_lines-i), end="")
    print("*" * (2*i+1))

#下半部分
for i in range(half_lines-1):
    print((" ")*(i+2), end="")
    print("*" * (lines-2-2*i))
'''请输入奇数行： 5
   *
  ***
 *****
  ***
   *'''

#空心菱形
side = int(input("请输入菱形每条边星星的个数: "))
a = side
b = side

print(" "*(a-1), "*")

#上半部分菱形
for i in range(2, a+1):
    print(" "*(a-i), "*", " "*(2*i-4), "*")

#下半部分
for i in range(b-1, 1, -1):
    print(" "*(b-i), "*", " "*(2*i-4), "*")

print(" "*(side-1), "*")
'''请输入菱形每条边星星的个数: 5
     *
    *  *
   *    *
  *      *
 *        *
  *      *
   *    *
    *  *
     *'''

五、N宫格横竖斜和相等算法

lines = int(input("请输入奇数行数： "))

array = [[0] * lines]

for i in range(lines):
    array = array + [[0] * lines]

row, col = 0, lines // 2

for i in range(1, lines * lines + 1):
    array[row][col] = i
    if i % lines == 0:
        row += 1
    elif row == 0:
        row = lines - 1
        col += 1
    elif col == lines - 1:
        row -= 1
        col = 0
    else:
        row -= 1
        col += 1

for i in range(lines):
    for j in range(lines):
        print("%02d" % array[i][j], end=" ")
    print()
'''
请输入奇数行数： 5
17 24 01 08 15
23 05 07 14 16
04 06 13 20 22
10 12 19 21 03
11 18 25 02 09
'''

如今才懂的多位数的解法 🤦‍♂

n奇数幻方口诀：

数字1放在第一行中间

依次放在上一个数的右上角

2.1若是右边出去了就回到左边（3，4） 2.2 若是上面出去了就放下面（1，2） 2.3 若是右上角有了就放在这个数的下面

六、水仙花数

水仙花数指一个三个位，其个位数字的立方和等于该数自己，如153 = 1^3+5^3+3^3

#查找100~1000之间的水仙花数
for i in range(100, 1000):
    a = i % 10
    b = i // 10 % 10
    c = i//100
    if a**3 + b**3 + c**3 == i:
        print(i,end="、")  
```

七、统计字符串里面的字母、数字、空格以及其余字符

input_str = input("请输入一个字符串：")

char_num, digit_num, char_kon, other_num = 0, 0, 0, 0

for c in input_str:
    if c.isdigit():
        digit_num += 1
    elif c.isalpha():
        char_num += 1
    elif c is " ":
        char_kon += 1
    else:
        other_num += 1

print("字母个数为：", char_num)
print("数字个数为：", digit_num)
print("空格个数为: ", char_kon)
print("其余字符个数：", other_num)
'''请输入一个字符串：qaz123_- - =——  +——23sasd^%&
字母个数为： 7
数字个数为： 5
空格个数为:  4
其余字符个数： 12'''

说明： str.isalpha() 判断是否由字符组成，str.isdigit() 判断是否由数字组成

函数

定义函数

一、语法格式：

def 函数名（形参列表）: //由零条到多条可执行语句组成的函数 return 返回值

二、从程序的可读性来看，函数名应该由一个或多个有意义的单词连缀而成，每一个单词所有小写，单词与单词之间使用下划线分隔。

三、函数的说明文档，在函数声明以后,注释说明便可。

def max(x,y):  
 '''  
 获取两个值较大的那个数  
 '''  
 max = x if x \> y else y  
 return max  
  
help(max)  
print(max.\_\_doc\_\_)

能够调用__doc__函数来看说明文档,也能够用help()函数来看说明文档

四、递归函数

在一个函数内调用它自身，被称为递归函数，定义递归函数时，递归必定要向已知方向进行，不然形成死循环。

函数参数

一、python要求将带默认值的参数定义在形参的最后，关键字参数必须位于位置参数的后面，意思是若传入两个参数，有一个是关键字参数，那另外一个就是位置参数，必须将位置参数放在传入参数的第一位，若此时关键字参数对应的事函数的第一位参数，则将与传入的参数起冲突。

例如：

def student(grade,number):
    print("I am in %d grade %d number" % (grade,number))

student(15,1)
student(grade=15,number=1)
student(number=1,grade=15)
student(15,number=1)
#不可将关键字参数放在前面，错误方式
#student(number=1,15)
#或者两个都指向同一个位置参数，错误
#student(grade=15,15)

二、参数收集（参数可变的参数）

说明：在形参前面添加一个星号，这就意味着该参数能够接受多个参数，多个参数会被当成元组传入，加两个星号该参数能够收集字典。

def foo(x,\*y):
    print("x参数：",x)
    print("y参数:",y)
foo(1,2,3,4,"伍")
#逆向参数收集
my\_tuple = (1,2,3,4)
foo(\*my\_tuple)

'''
x参数： 1
y参数: (2, 3, 4, '伍')'''
'''

观察结果，y传入的参数是一个元组

三、逆向参数收集

说明：指的是在传入的列表、元组参数以前添加一个星号，字典添加两个，可使他们的元素拆开来传递。

可见，它传入的参数是一个已经定义的数组，逆向参数收集方式能够把这个数组拆开传递。

lambda表达式

格式：lambda [parameter_list]: 表达式

说明： lambda关键字以后，冒号左边的是参数列表，能够没有参数，也能够用逗号隔开的多个参数，右边是该lambda表达式的返回值。

#例子
lambda x,y:x + y
#等同于
def sum(x,y):
     return x + y

调用函数

说明：__name__是Python中一个隐含的变量它表明了模块的名字
只有被Python解释器直接执行的模块的名字才是__main__

类和对象

定义类

class [name]():可调用参数

类可继承，父类写在括号里，默认是object参数，全部的类都是object的继承类的实例化叫对象，对象是存在的具体

def __init__(self,):
#也叫作构造方法，self参数是默认的，也就是自动绑定到构造方法初始化的对象。

class Student(object):
    def __init__(self,name,age,height):
        self.name = name
        self.age  = age
        self.height = height
    def student_name(self):
        print("The boy who watching book is name %s" % self.name,end=",")
    def student_age(self):
        print("ia a %d boy"%self.age,end=",")
    def student_height(self):
        print("and am is %5.2f tall."%self.height)

def main():
    student_A = Student('sun',20,175)
    student_A.student_name()
    student_A.student_age()
    student_A.student_height()

if __name__ == "__main__":
    main()

类能够调用实例方法，类方法与静态方法区别是：类方法会自动绑定第一个参数class到类自己，而静态方法则不会。

注意：在英语交谈中，使用复数来表示一个类如birds-鸟类，可是python中约定使用单数并将首字母大写。

@函数装饰器

在函数前加@表示将被装饰的函数被做为一个从参数传给了装饰函数，而且将返回值给被装饰函数，所以被装饰的函数此时可能再也不是一个函数而多是一个值或字符串。

def funB(fn):
    print('B')
    fn()#执行传入的fn参数
    return 'result'

@funB
def funA():
    print("A")
print(funA)

step1：将funA做品为参数传给funB,即funB(funA)。

step2: 将funA替换成step1的返回值即’result‘，此时funB不在是一个函数而是一个字符。

变量

变量分为类变量和实例变量，分属不一样的命名空间，从而调用的时候方式就不同。

类命名空间对象均可以访问。

property()定义属性 property（getting,setting,doing,doc） property函数有四个参数，分别是不读不写、只读、读写、读写删。其实程序尝试对对象进行读写操做都被委托给了property里参数表明的方法来实现。

封装

封装指将对象的信息隐藏在对象内部，用户只能经过对象访问。python使用双下划线来表示变量隐藏起来，但实际并无隐藏，经过类依旧能够访问。

类中将双下划线开头（__）的认定为隐藏属性，Import*不会导入隐藏属性的变量、方法。

直接访问下划线开头的方法会被python报错，能够经过类访问，但一般不会这么作，由于隐藏属性就是不但愿外部人员能直接访问。

继承

一个子类能够继承多个父类，只须要在类命名是在后面括号类声明便可。子类继承父类的方法。户能够直接从写父类方法，也可使用未绑定方法调用被重写的方法，须要注意的是：在经过类名调用实例方法时，python不会为实例方法的第一个参数self自动绑定值，而是须要本身显式绑定self，这种机制被称为未绑定方法。

使用super()调用父类的构造方法， python在继承多个父类时，排在前面的构造方法会被优先使用 super（）会自动绑定第一个参数self

def __init__(self,method1,method2...):
    #使用super方法重构造属性
    super().__init__(methods1)
    #直接经过继承的父类重构造
    class2.__init__(self,method2)

多态

当同一变量在调用同一个方法时，彻底可能呈现不一样的多种行为，这就是多态。 issubclass(cls,class or tuple):检查cls是不是后一个类或元组的子类 isinstance(obj,class or tuple)检测obj是不是后一个类或元组的对象

**__slots__限定属性**

lass Person(object):
   # 限定Person对象只能绑定_name, _age和_gender属性
    __slots__ = ('_name', '_age', '_gender')

python语言的动态性

动态性指对象、方法都是能够增删修改的，类都是type（）方法建立的，type（'类名'，（object）,dict(,)） __slots__动态添加方法属性

异常处理

try:
    x = int(input("please input a number: "))
    y = int(input("please input a number: "))
    print(x/y)
except:
    print("something wrong...")

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

当咱们认为某些代码可能会出错时，就能够用try来运行这段代码，若是执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，若是有finally语句块，则执行finally语句块，至此，执行完毕。

二、断言assert、logging也是调试异常处理的重要方式

参考资料

骆昊大神GitHub Python-100-Days-master
python3基础芒努斯·利·海特兰德

疯狂的python讲义李刚

python教程廖雪峰

...

学无止境，未完待续...