datawhaleDay1:Python基础

1、环境搭建和基础课程推荐

对于Python小白来说，推荐安装anaconda，可参考链接link，或link。

Python入门基础课程推荐：
（1） 廖雪峰的Python教程，这是很多Python爱好者的入门教程，link
（2）菜鸟教程：link

2、Python初体验：输入和输出

（1）输出：print()
用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。

print("Hello,world!");

print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出。
-注意：print()会依次打印每个字符串，遇到逗号“,”会输出一个空格。

print("java","python","sql")

print()也可以打印整数，或者计算结果。

print(300,100)
print(300+100)
print('300+100=',300+100)  
# 单引号内为字符串，print依次打印出字符串，但对于300+100，Python解释器自动识别为公式计算，直接打印出结果。

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""。

（2）输入：input()
Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里。要打印出name变量的内容，除了直接写name外，还可以用print()函数。

print(input())
input('Please input your name.') # 在输入交互时可以增加提示语句。
name = input('Please input your name.') # 把输入的内容存储到变量name里，无打印输出。
name
print(name,type(name))  # input()输入的结果在输出中是str格式。

3、Python基础

（1）python变量特性+命名规则
有关变量的规则：
–变量名只能包含字母、 数字和下划线。 变量名可以字母或下划线打头， 但不能以数字开头。
–变量名不能包含空格， 但可使用下划线来分隔其中的单词。 例如， 变量名greeting_message。
–不要将Python关键字和函数名用作变量名， 即不要使用Python保留用于特殊用途的单词， 如print 。
–变量名应既简短又具有描述性。 例如， name比n好， student_name比s_n好。
–慎用小写字母l和大写字母O， 因为它们可能被人错看成数字1和0。
–Python区分大小写，例如，user和User是不同变量。

（2）注释方法
Python的注释有单行注释和多行注释。
单行注释以#开头（按照PEP规范建议#后加一个空格），多行注释可以用多个#，也可以’’’……’’'或"""……"""。

# 这是单行注释。
print('hello,python!')
# 这是多行注释。
# 打印出hello，python！
'''
这是多行注释。
打印出hello，python！
'''

（3）python中“：”作用
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。

（4）学会使用dir( )及和help( )
dir()：查看变量可用的函数或方法。
help()：查看模块、函数、变量的详细说明。

（5）import使用
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(datetime)导入，格式为： import datetime
从某个模块中导入某个函数,格式为： from datetime import datetime
从某个模块中导入多个函数,格式为： from datetime import datetime,timedelta
将某个模块中的全部函数导入，格式为： from datetime import *

4、PEP8规范

PEP8规范比较全的资料：
（1）PEP 8 – Style Guide for Python Code：link
（2）PEP8中文翻译：link

比较需要注意的地方：可参考link:https://www.jianshu.com/p/ffcc66bab3ce

（1）缩进：每一级缩进使用4个空格，同一个代码块的语句必须包含相同的缩进空格数。

（2）多行语句：
-Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句。

total = item_one + \
        item_two + \
        item_three

-在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()。

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

（3）空行：
–函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。
–类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
–空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
–记住：空行也是程序代码的一部分。

（4）import导入：
–导入通常在分开的行；
–导入总是位于文件的顶部，在模块注释和文档字符串之后，在模块的全局变量与常量之前。
–导入应该按照以下顺序分组：
1）标准库导入
2）相关第三方库导入
3）本地应用/库特定导入

（5）约定俗成的命名规定
1）Names to Avoid 应避免的名字
–永远不要使用字母‘l’（小写的L），‘O’（大写的O），或者‘I’（大写的I）作为单字符变量名。
–在有些字体里，这些字符无法和数字0和1区分，如果想用‘l’，用‘L’代替。
2）Class Names 类名
–类名一般使用首字母大写的约定。
–在接口被文档化并且主要被用于调用的情况下，可以使用函数的命名风格代替。
–注意，对于内置的变量命名有一个单独的约定：大部分内置变量是单个单词（或者两个单词连接在一起），首字母大写的命名法只用于异常名或者内部的常量。
3）Function Names 函数名
–函数名应该小写，如果想提高可读性可以用下划线分隔。
–大小写混合仅在为了兼容原来主要以大小写混合风格的情况下使用（比如 threading.py），保持向后兼容性。
4）Function and method arguments 函数和方法参数
–始终要将 self 作为实例方法的的第一个参数。
–始终要将 cls 作为类静态方法的第一个参数。
–如果函数的参数名和已有的关键词冲突，在最后加单一下划线比缩写或随意拼写更好。因此 class_ 比 clss 更好。（也许最好用同义词来避免这种冲突）

5、python数值基本知识

（1）python中数值类型：int,float,bool,complex。

a = 10
b = 20.2
c = True
d = a+3j
print(type(a)); print(type(b)); print(type(c)); print(type(d))  # type()可查看变量的数据类型
'''
print结果:
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>
'''
a = 111
isinstance(a,int)  # 结果输出True 或 False。 isinstance()也可用来判断变量类型。

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

class A:
    pass

class B(A):
    pass

print(type(B()))  # <class '__main__.B'>
print(isinstance(B(),A))  # True
print(isinstance(B(),B))  # True

（2）算数运算符

# 算术运算符
a = 21
b = 10
c = 0
c = a + b
c = a - b
c = a * b
c = a / b
c = a // b  # //:取整除，向下取接近除数的整数。
c = a % b  # %:取模,返回除法的余数。

a = 2
b = 3
c = b ** a  # **:幂乘法

（3）逻辑运算符

# 逻辑运算符
a = 1
b = 2
print(a and b)  # 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
print(a or b)  # 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
print(not (a and b))  # 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

（4）成员运算符

# 成员运算
a = 10
b = 20
List = [1, 2, 3, 4, 5]
a in List  # 如果在指定的序列中找到值返回 True，否则返回 False。
b not in List  # 如果在指定的序列中没有找到值返回 True，否则返回 False。

if a in List:
    print('a is in List.')
else:
    print('a is not in List.')

if b not in List:
    print('b is not in List.')
else:
    print('b is in List.')

（5）身份运算符：身份运算符用于比较两个对象的存储单元。

# 身份运算符（用于比较两个对象的存储单元）
x = 10
y = 10
z = 20
print(id(x))  # 1798472048
print(id(y))  # 1798472048
print(id(z))  # 1798472368

# x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False.
print(x is y)  # is 是判断两个标识符是不是引用自一个对象.  True
# x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
print(x is not y)  # is not 是判断两个标识符是不是引用自不同对象.  False
print(y is z)  # False

（6）比较运算符（即关系运算符）

# 比较运算符（关系运算符）
a = 21
b = 10
print(a == b)  # False
print(a != b)  # True.  a <> b 也是不等于
print(a > b)  # True
print(a < b)  # False
a = 10
print(a >= b)  # True
print(a <= b)  # True

（7）赋值运算符

'''赋值运算符
运算符	描述	                     实例
 =	  简单的赋值运算符	  c = a + b 将 a + b 的运算结果赋值为 c
 +=	  加法赋值运算符	  c += a 等效于 c = c + a
 -=	  减法赋值运算符	  c -= a 等效于 c = c - a
 *=	  乘法赋值运算符	  c *= a 等效于 c = c * a
 /=	  除法赋值运算符	  c /= a 等效于 c = c / a
 %=	  取模赋值运算符	  c %= a 等效于 c = c % a
 **=  幂赋值运算符	  c **= a 等效于 c = c ** a
//=	  取整除赋值运算符	  c //= a 等效于 c = c // a
'''
a = 21
b = 10
c = 0
c = a + b
c += a
c -= a
c *= a
c /= a
c %= a  # 取余
c = 2
c **= a
c //= a  # 取整除

（8）位运算符：按位运算符是把数字看作二进制来进行计算的。

（9）运算符优先级

# 运算符优先级
a = 20
b = 10
c = 15
d = 5
e = 2

e = (a + b) * c / d  # ( 30 * 15 ) / 5 = 90.0
e = ((a + b) * c) / d     # (30 * 15 ) / 5 = 90.0
e = (a + b) * (c / d)  # (30) * (15/5) = 90.0
e = a + (b * c) / d  # 20 + (150/5) = 50.0
f = d ** e * b  # (5 ** 2) * 10 = 250

6、string字符串

（1）定义及基本操作（+，*，读取方式）
字符串是一种常用的数据类型，Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。Python 访问子字符串，可以使用方括号来截取字符串。

# 字符串基本操作
a = "Hello"
b = "Python"

print("a + b 输出结果：", a + b)  # +:字符串连接；输出结果： HelloPython。
print("a * 2 输出结果：", a * 2)  # *:	重复输出字符串；输出结果： HelloHello。
print("a[1] 输出结果：", a[1])  # []:通过索引获取字符串中字符；索引数值从0开始。输出结果： e。
print("a[1:4] 输出结果：", a[1:4])  # [:]:截取字符串中的一部分，遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的。输出结果： ell。

# 成员运算符 - 如果字符串中包含给定的字符返回 True
if "H" in a:
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

# 成员运算符 - 如果字符串中不包含给定的字符返回 True
if "M" not in a:
    print("M 不在变量 a 中")
else:
    print("M 在变量 a 中")

# 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 
# 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）。
print(r'\n')  # \n
print(R'\n')  # \n

（2）字符串相关方法

# 字符串常用内建函数：
s = 'python'
h = 'hello'
print(s.capitalize())  # capitalize():将字符串的第一个字符转换为大写.  Python
print(s.center(20))  # center(width, fillchar):返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

# count(str, beg= 0,end=len(string)):
# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
print(h.count('l'))

# encode(encoding='UTF-8',errors='strict'):
# 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'.

# endswith(suffix, beg=0, end=len(string)):
# 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
# startswith(substr, beg=0,end=len(string))
# 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
print(s.endswith('on'))
print(s.startswith('py'))

# find(str, beg=0 end=len(string))
# 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1;
# index(str, beg=0, end=len(string))
# 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
print(h.find('he'))  # 0
print(h.find('lo'))  # 3
print(s.find('he'))  # -1
print(s.index('he'))  # ValueError: substring not found

# isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False.
# isalpha():如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False.
# isdigit():如果字符串只包含数字则返回 True 否则返回 False.
# islower():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False.
# isupper():如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False.
# isnumeric():如果字符串中只包含数字字符，则返回 True，否则返回 False.
# isspace():如果字符串中只包含空白，则返回 True，否则返回 False.
# istitle():如果字符串是标题化的(见 title())则返回 True，否则返回 False
a = 'hello,Python3  !'
b = 'helloPython'
c = '234'
print(a.isalnum())
print(b.isalnum())
print(c.isalnum())

print(a.isalpha())
print(b.isalpha())

print(a.isdigit())
print(c.isdigit())

print(a.islower())
print(b.islower())  # False
print(c.islower())

print(a.isupper())
print(b.isupper())  # False
print(c.isupper())

print(a.isnumeric())
print(c.isnumeric())  # True

print(a.isspace())  # False


# join(seq)：以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
a = 'hello python hello java'
print(','.join(a))  #  h,e,l,l,o, ,p,y,t,h,o,n, ,h,e,l,l,o, ,j,a,v,a
# len(string)：返回字符串长度
print(len(a))  # 23
print(a.upper())  # upper():小写转换成大写   lower():大写转换成小写
print(a.lstrip())  # lstrip():截掉字符串左边的空格或指定字符。  rstrip():删除字符串字符串末尾的空格.  strip([chars]):在字符串上执行 lstrip()和 rstrip()
print(a.replace('hello','hi'))  # replace(old, new [, max]):把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
# split(str="", num=string.count(str)):num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
print(a.split(' '))  # ['hello', 'python', 'hello', 'java']

（3）字符串格式化问题
有两种方法：一种使用占位符（%），另外一种使用字符串的format方法（str.format()）。

# 字符串格式化
'''方法1
常见的占位符（%）有：
占位符	替换内容
    %d	整数
    %f	浮点数
    %s	字符串
    %x	十六进制整数
'''
a = 10
b = 5
c = a / b
print('a/b =%d'%c)  # a/b =2
print('a/b =%f'%c)  # a/b =2.000000
print('a/b =%.2f'%c)  # a/b =2.00   指定浮点数的小数点后的位数
s = "python"
print('Hello %s!'%s)

name = '小黑'
age = 6
print('我家养了一只狗，名字叫%s，今年%d岁了。'%(name,age))  # 我家养了一只狗，名字叫小黑，今年6岁了。

# 方法2：使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……。
print('a/b ={}'.format(c))  # a/b =2.0  format无需指定数据类型，会自动识别。
print('a/b ={:.2f}'.format(c))  # a/b =2.00 {:.2f}指定数据类型是浮点数且保留小数点后两位。
print('我家养了一只狗，名字叫{}，今年{}岁了。'.format(name,age))  # {}无显示变量所在的数值位置，则默认按照.format后面的参数顺序.
print('我家养了一只狗，名字叫{1}，今年{0}岁了。'.format(age,name))   # {0} {1} 指定变量的数值位置。

7、作业

要求用户依次输入姓名，性别，年龄，并对用户信息进行输出格式如下：您的姓名是：***，您的性别是：***，您是***年出生的。

name = input('请输入您的姓名:')
gender = input('请输入您的性别（男/女）:')
age = input('请输入您的年龄:')
birth = 2019 - int(age)
print("您的姓名是：{}，您的性别是：{}，您是{}年出生的。".format(name,gender,birth))
'''输出结果：
请输入您的姓名:>? Huang
请输入您的性别（男/女）:>? 女
请输入您的年龄:>? 20
您的姓名是：Huang，您的性别是：女，您是1999年出生的。
'''