python

pycharm安装、配置和使用指南

terminal：终端

administrator：管理员用户

new scratch file:创建新的暂存文件

plugin:插件

External Libraries:外部库

pycharm运行py文件快捷键：ctrl+shift+F10

setting

"""
作者：${USER}
日期：${YEAR}年${MONTH}月${DAY}日
"""

#""""""指字符串
#$(美元符)+{}指变量

python基础知识学习

1. 原始数据类型和运算符

1. 除法：自动转为浮点数

print(35/5)        # => 7.0
print(36/5)        # => 7.2

2. 整数除法(//)：结果向下取整

print(35//5)    # => 7
print(36//5)    # => 7
print(36.0//5.0)    # => 7.0
print(-5//3)    # => -2

3. x的y次方：2**4=16

4. 用not给布尔值取非：

print(not True)        # => False
print(not False)    # => True
#print(not TRUE)    #报错，True和False严格区分大小写

5. 逻辑运算符and和or(与和或)，and和or均为小写，严格区分大小写

print(True and False)    # => False
print(False or True)    # => True
print(True and True)    # => True

6. 大小比较连起来

print(2>3<1)    # => False
print(3<4>1)    # => True
#并不是逐个比较，即2>3得False(0),0<1结果应为True
#而是同时对左右进行比较：3<4为True，4>1为True，所以结果为True

7. 字符串可以用单引号或者双引号

print('i am 字符串')    
print("i am 字符串")    #两种方法都可以，一般情况下使用双引号

8. 用加号连接字符串，类似于java

print("hello "+"python")    # => hello python

9. 字符串可以当作字符数组来访问数组元素

print("this is a new problem"[2])    # => i
#print("this is a new problem"[2][3][5]) #输出结果并不为isi，报错信息为string index out of range，推测可能被当作多维数组
#以下情况倒是可以
print("this"[2]+"is"[0]+"my"[0])    # => iim

10.用.format来格式化字符串

print("{} can be {}".format("strings","interpolated"))    # => strings can be interpolated
#interpolated:插入，以内插值替换的
#格式：   "字符串{待格式化内容}".format("格式化内容")
#不加控制符号为逐个替换

11. 可以使用重复参数节省时间(添加控制符)

    print("{0} is a real foolguys , but {0} is pretty funny , {1} ,oh i don't konw".format("a","b"))
    
    # => a is a real foolguys , but a is pretty funny , b ,oh i don't konw
    
    #{0}被替换成format的第一个字符串参数
    #{1}被替换为format的第二个字符串参数

12. 也可以用类似于微信小程序的关键字数据绑定

print("{name} just want to say it's too long".format(name="i"))
# => i just want to say it's too long

#老式格式化语法类似于C中的scanf，仅作了解

13. None

    None是一个对象

#print(none)        #此语句将导致后面无法输出
print(None)        # =>None
print("etc" is None)    #False
print(None is None)        #True

14. 特殊的布尔判断

print(bool(0))        #False
print(bool(None))    #False
print(bool({}))        #False    空列表
print(bool([]))        #False    空字典？
#所有其他值都是True

2.变量和集合

列表

1. 在给变量赋值前不用提前声明
2. 用列表(list)储存序列

li=[1,2,4]    #创建列表
print(li[0])    # => 1   ##像访问数组一样访问列表元素

3. 用append在列表最后追加元素/用pop从列表尾部删除/直接取出列表最后一个元素

#续上
li.append(5)    #此时li列表元素为[1,2,4,5],即自动在末尾加
print(li[3])    #可以直接访问这个新加入的元素

li.pop()        #中间没有参数是直接删除最后一个，此时li列表元素为[1,2,4]
#print(li[3])    #报错：list index out of range

print(li[-1])    #无论列表长度为多少，直接取出最后一个元素

列表的切割语法

可以用三个参数的任何组合来构成切割：list[始：终：步伐]

步伐省略默认为1，即逐个访问

两种理解方式：

0-1存储第一个元素，1-2存储第二个元素

始终按数组形式从0开始，这种方式不访问终坐标的元素

li=[1,2,4,3]
print(li[0:1])    # => [1]    #注意输出的元素带[]
print(li[2:3])    # => [4]
print(li[1:3])    # => [2,4]
#取尾
print(li[0:2])    # => [1,2]
print(li[:2])    # => [1,2]
#取头
print(li[2:4])    # => [4,3]
print(li[2:])    # => [4,3]
#逐个取/隔一个取一个
print(li[::1])    #[1,2,4,3]
print(li[::2])    #[1,4]
#倒序取
print(li[::-1])    #[3,4,2,1]

列表2

#用del删除任何一个元素
list=[1,2,4,3]    #定义并初始化列表
del list[0]        #用del删除任何一个元素
del list[-1]    #用del删除最后一个元素
print(list)        #[2,4]
                #不像C++不能直接输出非字符数组

#列表可以相加，并且相加的原列表值不变
#续上
list2=[6,5,7]
print(list+list2)        # => [2,4,6,5,7]
print((list+list2)[1])    # => 4                #访问拼接后的单个元素
print(list)                # => [2,4]
print(list2)            # => [6,5,7]

#用extend拼接列表
list.extend(list2)        
print(list)                # =>[2,4,6,5,7]

#用in测试列表是否包含某个值 格式：要测试是否包含的值+in+列表名
print(1 in list)    # => False    #list中并没有1
print(2 in list)    # => True    #list中有2

#用len获取列表长度
print(len(list))    # => 5 

元组(tuple)

元组是不可改变的序列

#元组特殊的地方
tup1=(1,2,3)        #用括号初始化和定义
print(tup1[1])        # => 2    像列表一样用[]访问元素
#tup1[2]=4            #    尝试修改元组元素，报错：'tuple' object does not support item assignment(元组对象不支持项目分配)
print(tup1[2])        # => 3

#元组可以进行大部分列表的操作
#tup1.append(1)        #报错：'tuple' object has no attribute 'append'，tuple对象没有append属性，同理没有pop()
#取出最后一个元素
print(tup1[-1])        # => 3
#切割取法(注意有点不一样)
print(tup1[1:2])    # => (2,)
print(list[1:2])    # => [4]
print(tup1[0:2])    # => (1,2)
print(tup1[0:])        # => (1,2,3)
#相加/拼接/包含/取长度
print(tup1+(3,5,6))    # => (1,2,3,3,5,6)
tup1+(4,5,6)        #元组无法改变，包括拼接，只能通过拼接改变输出
print(tup1)            # => (1,2,3)
print(len(tup1))    # => (3)
print(4 in tup1)    # => False
#元组特殊的地方
#可以把元组和列表解包，赋给变量
a,b,c=[1,2,3]
print(a,b,c)    # => 1 2 3
d,e,f=(4,5,6)
print(d,e,f)    # => 4 5 6
#print中逗号，被当作分隔符，输出的数字被转为中间为空格
#元组周围的括号可以省略
d,e,f=7,8,9
print(d,e,f)    # => 7 8 9

#！！！
#交换两个变量的值
a=b
b=a
print(a,b)        # => 2 2
#同时进行改变，不需要中间变量
d,e=e,d
print(d,e,f)    # => 8 7 9
#！！！

字典(dict)dictionary

特别注意：keys和列表的结合

#空字典
empty_dict={}
#初始化字典
#filled_dict={"one"=1,"two"=2,"three"=3}    #报错：invalid syntax 无效语法

#正确的赋值方式是“键值对”的形式
filled_dict={"one":1,"two":2,"three":3}
print(filled_dict)                # => {'one': 1, 'two': 2, 'three': 3}
#访问字典元素
#print(filled_dict[1])        #报错：keyerror
print(filled_dict["one"])    # => 1

#字典中的keys
#用keys获得字典中所有的键(没有值)
another_dictionary={"four":4}        
print(another_dictionary.keys())    # => dict_keys(["four"])
print(filled_dict.keys())            # => dict_keys(["one","two","three"])

#用keys返回一个“可迭代”的对象，所以可以把结果放在一个list中
filled_dict={"one":1,"two":2,"three":3}
print(list(filled_dict.keys()))            # => ["one","two","three"]

#用values获得所有的值(没有键)
print(list(filled_dict.values()))        # => [1,2,3]

#用in测试一个字典中是否包含某个键
print("one" in filled_dict)        # => True
print(1 in filled_dict)            # => False
#仅能判断键，所有的值都会判断为False
#回顾字典访问元素的方式
print(filled_dict["one"])    # => 1

字典2

1. 访问不存在的键

print(filled_dict["four"])        #报错：keyerror

2. 用get访问字典元素,可以避免keyerror

print(filled_dict.get("one"))    # => 1
print(filled_dict.get("four"))    # => None，返回空对象

3. 带两个参数的get访问

print(filled_dict.get("one",4))        # => 1
#字典中存在访问可访问的的键，则返回其对应的值
print(filled_dict.get("four",5))    # => 5
#字典中不存在可访问的键，将第二个参数作为默认值输出

4. 用setdefault在只有当键不存在的时候插入新值

other_dict.setdefault("sun",7)        
other_dict.setdefault("sun",6)
print(other_dict.get("sun",5))        # => 7
print(other_dict.keys())    # => dict_keys(['mon', 'tue', 'wedn', 'sun'])
#1.只有第一次设置才有效
#2.会将这个键值对插入到字典里

5. 用del删除键值对

#other_dict.del("mon")报错
#del other_dict("mon")报错
del other_dict["mon"]
print(other_dict)        # => {'tue': 2, 'wedn': 3, 'sun': 7}

集合

1. 集合即数学意义上的数的集合，包括其特点

#集合基础
empty_set=set()            #用set表达集合
some_set={1,1,2,3,4,4}    #集合的初始化方法
var_set=some_set        #把集合作为一个整体赋给变量
print(some_set)            # => {1,2,3,4}
print(empty_set)        # => set()
print(var_set)            # => {1,2,3,4}

#集合运算
#&取交集
#|取并集
##-取补集##
other_set={2,4,5}
print(some_set&other_set)        # => {2,4}
third_set=some_set|other_set    
print(third_set)                # => {1,2,3,4,5}
#这里取补集是双目运算符，可以当成减
print(some_set-other_set)        # => {1,3}

#集合包含in
print(3 in some_set)            # => True

3. 流程控制和迭代器

if-else

#不需要加括号，但是注意缩进会影响代码
#if、else、elif(else+if)后跟的语句要加冒号:

#1
some_var=5
if some_var>=10:
    print("some_var大于等于10")
else:
    print("some_var小于10")
# => some_var大于等于10

#2
#elif后记得加判断条件
if some_var>10:
    print("some_var大于10")
elif some_var==10:
    print("some_var等于10")
else:
    print("some_var小于10")
# => some_var小于10

for

#字符串循环
for animal in {"dog","cat","mouse"}:        #for 迭代的对象 in {}/[]
print("{} is a animal".format(animal))        #自动格式化，但是为什么自动从dog到mouse呢
""" =>
dog is a animal
cat is a animal
mouse is a animal
"""
#数字循环    关键字range，返回数字列表从0到给的数字
for i in range(4):
    print(i)
"""自动换行
0
1
2
3
"""

while

x=0
while x<4:
    print(x)
    x+=1
#while冒号后的都处在while循环里
"""
0
1
2
3
"""

异常处理

用try/except块处理异常情况

迭代与迭代器

Python提供一个叫做可迭代（iterable）的基本抽象。一个可迭代对象是可以被当作序列的对象。比如说上面range返回的对象就是可迭代的

#my_iterable是一个实现可迭代接口的对象
filled_dict={"one":1,"two":2,"three":3}
my_iterable=filled_dict.keys()
print(my_iterable)
# => dict_keys(["one","two","three"])

#可迭代对象可以遍历
for i in my_iterable:
    print(i)
"""
one
two
three
"""
#但是可迭代对象不可以随机访问
#print(my_iterable[1])，会导致后面的错误输出

#可迭代对象与迭代器
#可迭代对象生成迭代器，关键字iter
my_iterable=iter(my_iterable)
#迭代器是一个可以记住遍历位置的对象
print(my_iterable.__next__())    # => one
print(my_iterable.__next__())    # => two
print(my_iterable.__next__())    # => three 
#print(my_iterable.__next__())    # 抛出StopIteration

#可以用list一次去除迭代器所有的元素
print(list(filled_dict.keys()))
# => ['one', 'two', 'three']

4. 函数

用def定义新函数

调用函数

def exchange(a,b):
    print("before change a={},b={}".format(a,b))
    print("after change a={},b={}".format(b,a))
    return a+b
sum=exchange(5,10)
print(sum)
"""
before change a=5,b=10
after change a=10,b=5
15
"""

用关键字参数调用函数

#关键字参数可以用任意顺序
def exchange(a,b):
    print("before change a={},b={}".format(a,b))
    print("after change a={},b={}".format(b,a))
    return a
new_a=exchange(b=13,a=7)
print(new_a)
"""
before change a=7,b=13
after change a=13,b=7
7
"""

形参与实参！！！区别于C++

def changevalues(a,b):
    print(a,b)
    a,b=b,a
    print(a,b)
    return a
new_a=changevalues(a=11,b=7)
print(new_a)
#形参可以影响实参
"""
11 7
7 11
7
"""

可变参数函数与关键字可变参数函数

#*args,args是参数，那么*是代表可变参数吗？
#(1,2,3)是一个元组，作为参数传递
def varargs(*args):
    return args
print(varargs(1,2,3))
# => (1, 2, 3)

#args和kwargs某种程度上是固定的
#kwargs并不是某种类型的变量，只是关键字对应
def keyword_args(**kwargs):
    return kwargs
print(keyword_args(big="foot",loch="ness"))
# => {'big': 'foot', 'loch': 'ness'}

#两种可变参数同时作为函数参数
def all_the_args(*args,**kwargs):
    print(args)
    print(kwargs)


print(all_the_args(1,2,a=3,b=4))
"""
(1, 2)
{'a': 3, 'b': 4}
None
"""

*调用可变参数函数时可以做跟上面相反的，用展开序列，用两个展开字典**

推测类似于C++地址传递中传递指针与传递对象的区别

为什么和上面的关键字可变函数不一样，这里是字典

kwargs={"one":1,"two":2,"five":5}
print(all_the_args(*args))
print(all_the_args(**kwargs))
print(all_the_args(*args,**kwargs))
"""
(1, 2, 3)
{'one': 1, 'two': 2, 'five': 5}
None
"""
# => 最后一句错误输出？

函数作用域

x=5
def setX(some_num):
    x=some_num
    print(x)

def setglobalX(other_num):
    global x
    print(x)
    x=other_num
    print(x)

setX(43)
setglobalX(13)
print(x)
"""
43
5
13
13
"""

函数的嵌套使用(分部传参)

def creat_adder(x):
    def adder(y):
        return x+y
    return adder
add_10=creat_adder(10)
print(add_10(3))        # => 13

匿名函数lambda

print((lambda x:x>2)(3))    # => True

内置的高阶函数？？？

map(add_10, [1, 2, 3]) # => [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]

5.类

创建一个类合理的缩进形式

定义类和类属性

class Human(object):
    species="H.sapiens"
#类属性即可以被所有类的实例共用的属性

类实例的初始化(构造)

#定义方式，注意名字前后的双下划线
def __init__(self,name):
    self.name=name

类实例的方法

第一个参数总是self，就是这个实例对象？？？

def say(self,msg):
    return "{name}:{message}".format(name=self.name,message=msg)

类方法(成员函数？)

#被此类实例共用，第一个参数是这个类对象
@classmethod
def get_species(cls):
    return cls.species

静态方法

调用时没有实例或类的绑定

@staticmethod
def grunt():
    return "grunt"

python的语法缩进影响构成

构造类的实例

i=Human(name="Ian")
print(i.say("hi"))
j=Human(name="joel")
print(j.say("hello"))

调用一个类方法

print(i.get_species())

改一个共用的类属性

Human.species="H.neanderthalesis"
print(i.get_species())
print(j.get_species())

调用静态方法

print(Human.grunt())

6.模板

用import导入模板

import math
print(math.sqrt(16))

也可以从模块中导入个别值

from math import ceil,floor
print(ceil(3.7))        # => 4
print(floor(3.7))        # => 3

可以导入一个模块中所有的值

from math import *

快捷使用模块(缩写模块名字)

import math as m
print(m.sqrt(16))
print(m.sqrt(16)==math.sqrt(16))

模块的实质

python模块其实就是普通的python文件，可以自己写，然后如上导入即可

模块的名字就是文件的名字

列出模块中所有的值

import math
print(dir(math))
# => ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

7.高级用法