Python入门

基本用法

num = 1
string = ‘1’
#print(num+1)
#print(type(string))
int(string)
#即使int（string）之后String的值没有变
#应该给string赋新值
print(num+int(string))
total = string*3
print(total)
#连续输出

字符串的分片和索引

name = “Alice in wonderland”
print(name[11:14])
#第一个数是起始位置，终止位置是第二个数之前

切片的实际应用：

python编写爬虫后，从网页解析出来的部分图片链接需要处理，也就是要给不同格式的图片以一个统一的方式进行命名。通过观察规律，决定以链接尾部倒数10个字符的方式命名。

url = "http:ww1.site.cn/14dfjahglajsdsdfa.jpg"
file_name = url[-10:]
print(file_name)

字符串的方法

使用手机号注册信息的时候，通常信息指挥显示后四位，其余的用*来代替。

phone_number = "1386-666-0006"
hiding_number = phone_number.replace(phone_number[:9],'*'*9)
#这里后面要进行覆盖的数要和前面的相对应，必须要*9，否则全部被替换成一个*
print(hiding_number)

字符串格式化符

填空题的模式

print('{} a word she can get what she {} for'.format('with','came'))
print('{preppsition} a word she can get what she {verb} for'.format(preppsition='with',verb = 'came'))
print('{0} a word she can get what she  {1} for'.format('with','came'))

这种字符串填空的方式使用很广泛，例如下面这段代码可以填充到网址中空缺的城市数据

city = input("write down the name of city:")
url = "http://apistore.baidu.com/weather?citypinyin={}".format(city)
print(url)

函数

内建函数：以3.5版本为例，一共存在68个这样的函数，被统称为内建函数，内建的意思是在安装完3.5版本之后，就可以使用他们，是“自带”的而已

创建函数

1. def:创建函数，也就是定义一个函数
2. arg（argument）:参数，有时还能看到parameter，这两者都是参数但是稍有不同
3. return:返回结果

def function(arg1,arg2):
    return 'something'
it = function(1,2)
print(it)

注意缩进

def fahrenheit_converter(C):
    fahrenheit = C * 9/5 +32
    print(fahrenheit)
c = fahrenheit_converter(35)
print(c)

注意这里返回值是None，如果不使用return 没有返回值，所以是none
在python中definition和declaration是一体的

def weight_converter(weight):
    return weight/1000
weight_g = input("please input the weight of things:")
weight_kg = weight_converter(int (weight_g))
print("the kg weight is {}".format(weight_kg))

传递参数与参数类型

传递参数的方式有两种：位置参数（positional argument）、关键词参数（keyword argument）

def traapezoid_area(base_up,base_down,height):
    return 1/2*(base_up+base_down)*height
traapezoid_area(1,2,3)
#这种传入参数的方式叫做"位置参数"

def traapezoid_area(base_up=1,base_down=2,height=3):
    return 1/2*(base_up+base_down)*height
traapezoid_area(1,2,3)
#这种传入参数的方式叫做"关键词参数"

traapezoid_area(height=3,base_down=2,base_up=1)
#反序传入，因为是关键词参数，所以不影响函数正常运作
traapezoid_area(height=3,base_down=2,1)
#反序传入，但是最后一个是位置参数，最后一个本来应该是height但是在前面已经出现height，所以出现错误
traapezoid_area(base_down=2,base_up=1,3)
#正序传入，前面两个关键词后面最后一个是位置是匹配的没有问题
traapezoid_area(1,2,height=3)
#最后一个关键词，也没有问题

默认参数，在函数定义的时候给函数的参数传递一个值
如果能在传入参数的时候给每个变量的名字都搞出来也就不用顺序了，如果没有指定就是按照定义函数的 顺序来的。

在实际项目中经常会看到：
requests.get(url,headers=header)
请求网站时header可填可不填

img.save(img_new,img_format,quantity=100)
给图片加水印的时候默认水印质量时100

设计自己的函数

def text_create(name,msg):
    desktop_path = '/users/hong/'
    full_path = desktop_path +name +'.txt'
    file = open(full_path,'w')
    file.write(msg)
    file.close()
    print("done")
text_create('hello','hello world')

1. 定义函数的名称和内容，name是文件名，msg是具体要写入文件的信息
2. ‘w’如果没有就在该路径创建一个有该文本的文件，有则追加覆盖文本内容
3. file.close()关闭文本
   避免混乱的方法是先制造混乱

def text_create(name,msg):
    desktop_path = '/users/hong/'
    full_path = desktop_path +name +'.txt'
    file = open(full_path,'w')
    file.write(msg)
    file.close()
    print("done")
text_create('hello','hello world')
def text_filter(word,censored_word='lame',changed_word='Awesome'):
    return word.replace(censored_word,changed_word)
print(text_filter('python is lame!'))

def censored_text(name,msg):
    clean_msg = text_filter(msg)
    text_create(name,clean_msg)
censored_text('hello','lame!lame!lame!')

敏感词过滤器

逻辑控制与循环

1. 多条件比较
2. 变量的比较
3. 字符串表
4. 函数产生的结果比较

middle = 5
print(1<middle<10)

two = 1+1
three = 1+3
print(two<three)

val = 'Alice in wonderland' == "alice in wonderland"
print(val)

val = abs(-10) > len('length of this word')
print(val)

⚠️

1. 不同类型的对象不能使用<><=>=但是可以使用== !=
2. 但是浮点和整型虽然是不同类型，但是不影响计算
3. <>也是不等于

成员运算符和身份运算符

in和is
把in放在两个对象之间的含义是，测试前者是否存在于后面的集合中。

album = ['black star','david bowie',25,True]
album.append('new song')
print(album[0],album[-1])
var ='black star' in album
print(var)

在python中任何一个对象都要满足身份（identity）、类型（type）、值（value）这三个点，缺一不可
is/is not：表示身份鉴别（identify Operator）的布尔运算符
in/in not：表示归属关系的布尔运算符（Membership Operator）

print(bool(0))
print(bool([]))
print(bool(''))
print(bool(False))
print(bool(None))

在python中任何对象都可判断其布尔值，除了上述哪些是false其余均为true

布尔运算符

not x:
x and y:
x or y:

条件控制

用户登陆输入密码：

def account_login():
    password = input("Password:")
    if password == '12345':
        print("login success!")
    else:
        print("worng password or invalid input!")
        account_login()
account_login()

分析：

1. 定义函数，并不需要参数
2. 使用input获得用户输入字符串并存储在变量password中
3. 设置条件
4. 再次调用，递归调用
   增加一个重置密码的功能：

password_list = ['*#*#','12345']
def account_login():
    password = input("Password:")
    password_correct = password == password_list[-1]
    password_reset = password == password_list[0]
    #print(password_reset)
    if password_correct:
        print("login success!")
    elif password_reset:
        new_password = input("please input new password:")
        password_list.append(new_password)
        print("your password has been changed!")
        account_login()
    else:
        print("worng password or invalid input!")
        account_login()
account_login()

很巧妙的利用了列表的append函数直接填到list的尾部，每次新的密码都填入到list的尾部，不需要修改当前的比较密码是否正确。而当用户忘记密码的时候，也可以通过对照之前列表中的密码来向系统确认当前用户是否真正忘记密码(自己又加了修改密码和限制修改密码次数）

password_list = ['*#*#','12345']

def account_login():
    count = 5
    other = input("do you forget your password? Y:yes N:no     :")
    #如果忘记密码的操作
    if other == 'Y' or other =='y':
        compare = input("please input your past password:(you have {} chances now!):y".format(count))
        if compare in password_list:
              print("identity successfully!")
              new_password = input("please input new password:")
              password_list.append(new_password)
              print("your password has been changed!")
              account_login()
        else:
             while count > 1:
                   print("your past password is wrong !")
                   count-=1
                   print("please reinput your past password:(you have {} chances now!):".format(count))
                   answer = input()
                   if answer in password_list:
                        print("identity successfully!")
                        account_login()
             print("login wrong! you have no chances!")
             return
    password = input("Password:")
    password_correct = password == password_list[-1]
    password_reset = password == password_list[0]
    #print(password_reset)
    if password_correct:
        print("login success!")
        var = input("Do you want to change your password? Y:yes N:no")
        if var == "Y" :
            new_password = input("please input new password:")
            password_list.append(new_password)
            print("your password has been changed!")
            account_login()
        else:
            return
    elif password_reset:
        new_password = input("please input new password:")
        password_list.append(new_password)
        print("your password has been changed!")
        account_login()
    else:
        print("worng password or invalid input!")
        account_login()
account_login()

循环（Loop）

1. for循环
   模型：for item in iterable：
   do something
   ⚠️in后面的对象一定是具有iterable可迭代的，或者说像列表那样的集合形态的对象，即可以连续地提供其中的每一个元素的对象

for every_letter in "helloworld":
    print(every_letter)
   

 for num in range(1,10):
    print(str(num)+'+1=',num+1)

2. 嵌套循环(nested loop)

for i in range(1,10):
    for j in range(1,10):
        print('{}*{}={}'.format(i,j,i*j))

infinte loop死循环
3. while循环
模型：while condition：
do something
如果while不能像for循环那样，在集合穷尽之后停下来，我们可以怎样控制while循环呢？
一种方式：在循环过程中制造可以使循环停下来的条件

count = 0
while True:
    print("repeat this line!")
    count+=1
    if count == 5:
        break

另一种方式：改变循环成立的条件
可以有while-else嵌套

练习题

1. 创建10个文本文件

def create_file(name,msg):
    home_path = "/users/hong/"
    full_path = home_path+name+".txt"
    file = open(full_path,'w')
    file.write(msg)
    file.close()
    print("the file created successfully!")
for i in range(1,11):
    create_file(str(i),'hello world')

2. 复利是能够将所有铅块变成金块的石头

def invest(amount,rate,time):
    for i in range(1,time+1):
        amount = amount*(1+rate)
    return amount
print(invest(100,0.05,5))

3.打印1～100内的偶数：

for i in range(1,101):
    if i % 2 == 0:
        print(i)

综合小练习

发展出设计与分解事物的思路，所谓逻辑关系就是不同事物之间的关联性，它们以何种方式连接、作用，又在什么边界条件下能实现转换或互斥

CN_mobiel = \
    [134, 35, 136, 137, 138, 139, 159, 151, 152, 157, 158, 159, 182, 183, 184, 187, 188, 147, 178, 1705]
CN_union = [130, 131, 132, 155, 156, 185, 186, 145, 176, 1709]
CN_telecom = [133, 153, 180, 181, 189, 177, 1700]


def identity_phone_number(phonenumber):
    if len(phonenumber)<11:
        print("Invalid length,your number should be in 11 digits")
    else:
        phonenumber_icon = int(phonenumber[0:3])
        print(phonenumber_icon)
        if phonenumber_icon in CN_mobiel:
            print("China mobiel")
            print("we are sending verfication code via text to your phone:{}".format(phonenumber))
        elif phonenumber_icon in CN_union:
            print("China union")
            print("we are sending verfication code via text to your phone:{}".format(phonenumber))
        elif phonenumber_icon in CN_telecom:
            print("China telecom")
            print("we are sending verfication code via text to your phone:{}".format(phonenumber))
        else:
            print("No such a operator")

var = input("Enter your phone number:")
while var != 'n':
    identity_phone_number(var)
    var = input("Enter your phone number:")

出现的小问题：一开始输入是字符串在匹配的 时候出现了问题应该先转换成int类型然后再进行list中的匹配

数据结构

python有四种数据结构：列表、字典、元组、集合

list = [val1,val2]
dict = {key1:val1,key2:val2}
tuple = (val1,val2)
set = {val1,val2}

list列表

列表最显著的特征

1. 列表中的每一个元素都是可变的：意味着可以在列表中添加、删除和修改元素
2. 列表中的元素是有序的，也就是说每一个元素都有一个位置
3. 列表可以容纳python中的任何对象

list的增删改查

插入元素：插入的实际位置是指定位置之前的位置，如果在指定插入的位置在列表中不存在，实际上也就是超出指定列表长度，那么这个元素一定会被放在列表的最后位置。

fruit = ['pineapple','pear']
fruit.insert(1,'grape')
print(fruit)

删除元素：

#方法一
fruit.remove('grape')
print(fruit)
#方法二
del fruit[0:2]
print(fruit)

替换元素：

fruit[0]='Grapefruit'
print(fruit)

列表的索引和字符串是一样的，但是如果要是反过来，想要查看某个具体的值所在的位置，就需要用别的方法了，否则会报错！

字典（dictionary）

字典的特征

1. 字典中数据必须是以键值对的形式出现的
2. 逻辑上讲，键是不能重复的，而值是可以重复的
3. 字典中的键（key）是不可变的，也就是无法修改的；而值是可变的，可修改的，可以是任何对象

nasdaq_code ={
    'bidu':'baidu',
    'sina':"Sina",
    'yuku':'youku'
}
key_test={[]:'atest'}

不能放置可变元素在key的位置上，否则会报错

key_text = {'key':123,'key':123}
print(key_text)

字典中的键值对不可以重复，即使写的时候重复，最后结果也还是只有一对

dictionary的增删改查

添加元素：字典并没有一个可以往里面添加单一元素的method，但可以通过下面这种方式添加：

nasdaq_code ={
    'bidu':'baidu',
    'sina':"Sina",
    'yuku':'youku'
}
nasdaq_code['you'] = 'wonderful'
print(nasdaq_code)

list中有添加多个元素的expend方法，字典中也有update方法

删除字典中的元素使用del方法：

字典使用的是花括号，在索引内容的时候，仍旧使用的是和列表一样的方括号进行索引，只不过在 括号中放入的一定是——字典中的键：

var = nasdaq_code['tsla']
print(var)

字典是不能够切片的

元组（tuple）

元组可以理解成和一个稳固版的列表，因为元组是不可修改的，因此在列表中存在的方式均不可以使用在元组上，但是元组是可以被查看索引的，方式和列表中一样

letters = (1,3,4)
letters[0]

集合（Set）

• 可以通过集合去判断数据的从属关系，有时还可以通过集合把数据结构中的重复元素减掉（利用此种数据结构本身被支持的特点去做一些事情）
• 集合不能被切片也不能被索引，除了做集合运算之外，集合元素还可以被添加和删除

a_set = {1,3,4,5}
a_set.add(2)
a_set.discard(5)
print(a_set)
#{1, 2, 3, 4}

数据结构的一些技巧

1. 多重循环
   整理列表常用的排序：

num_list = [6,2,7,4,1,3,5]
print(sorted(num_list))
print(sorted(num_list,reverse=True))

如果整理列表的时候有两个列表，使用zip函数：

num_list = [6,2,7,4,1,3,5]
print(sorted(num_list))
print(sorted(num_list,reverse=True))
num = [1,5,3,2,4]
str = "alice"
for a,b in zip(num,str):
    print(b,"is",a)
#num和str是对应的,如果数目不匹配,只匹配相等部分

2. 推导式（list comprehension）/列表解析式
   一般形式：

a =[]
for i in range(1,11):
    a.append(i)
print(a)

改进形式：

b = [i for i in range(1,11)]
print(b)

模型：

list = [item for item in iterable]

可以看成两部分：一部分是item，即我们想要添加到列表中的元素，另一部分是for循环的表达式，在这个例子中放在列表里的元素是后面循环的元素本身。

字典推导式的方式略有不同，因为涉及到键值对

3. 循环列表时获得元素的索引
在索引的时候得到每个元素的具体位置的展示：enumerate

letters = ['a','b','c','d','e']
for num,letter in enumerate(letters):
    print(letter,'is',num+1)

4. 综合项目

类

class attribute（类的属性）
类的实例化：
coke_for_me /coke_for_you

class cocacola:
    formula = ['caffeine','sugar','water','soda']
coke_for_me = cocacola()
coke_for_you =cocacola()
print(cocacola.formula)
print(coke_for_me.formula)
print(coke_for_you.formula)

类属性的引用（attribute reference）

coke_for_me.formula

实例属性：

coke_for_china = cocacola()
coke_for_china.local_logo ='可口可乐'#创建实例属性
print(coke_for_china.local_logo)

实例方法：

实际上self就是被实例化的类的对象的一个参数，也可以有自己的参数：

class cocacola:
    formula = ['caffeine','sugar','water','soda']
    def drink(self):
        print('energy!')
    def __init__(self):
        self.local_logo ='可口可乐'
coke_for_china = cocacola()
coke_for_china.drink()
print(coke_for_china.local_logo)
var = coke_for_china.drink() == cocacola.drink(coke_for_china)
print(var)

_init_()方法不需要调用，自动执行，相当于构造函数吧！

类的继承

比如无咖可乐
class caffeinefree(cocacola):
      caffeine = 0
      ingredients = ['high fructose corn syrup'.'carbonated water']
coke_a = caffeinefree('cacacola_free')
coke_a.drink()

继承只要把父类写在括号里就行
类中的方法和变量可以完全被子类继承，但如需有特殊的改动也可以进行覆盖（override）

类属性和实例属性

class testA:
    attr =1
obj_a =testA()
testA.attr = 42
print(obj_a.attr)

class testA:
    attr =1
obj_a =testA()
obj_b= testA()

obj_b.attr = 42
print(obj_a.attr)

实验表明，改变的实例属性只是属于实例自己的，类属性是属于全部实例的

class testA:
    attr =1
    def __init__(self):
        self.attr=42
obj_a =testA()
print(obj_a.attr)

最后改变的是_init_()中使用的内容，可以通过这种方式进行不同的实例需要的变量的赋值

_dict_属性说明，类和实例的属性是各自独立的，这个属性是一个字典用于储存类或实例的属性，即使不去定义它，也会存在于每一个类中，是默认隐藏的。

在python中属性的引用机制是自外向内的，当你创建了一个实例之后，准备开始引用属性，这个时候编译器会先搜索该实例是否拥有该属性，如果有则引用，如果没有，将搜索这个实例所属的类是否有该属性，如果有则引用，在没有就报错。

使用第三方库

查找安装路径：

import  sys
print(sys.path)

打印出来一个列表，第四个是你的库的安装路径：

import sys
print(sys.path[3])

安装自己的库

1. 找到你的python安装目录，找到下面的site-packages文件夹
2. 记住你的文件名，因为它将作为引用时的名称，然后将你写的py文件放进去

用pip安装第三方库

pip3 install PackageName
#使用pip3，pip是在Python2中安装
python3 -m pip install PackageName
#如果有python2或3两种版本，可能会遇到安装目录的问题，可以换成上面的形式
sudo pip install PackageName
#如果遇到权限问题，使用上面的
安装成功后会显示Successfully installed PackageName

pip install --upgrade pip
#升级pip
pip uninstall flask
#卸载库
pip list
#查看已安装库

安装某些库的时候可能会遇到所依赖的另一个库还没安装，导致无法安装成功的情况，这时候的处理原则是：缺啥装啥

最原始的方式：手动安装

往往是Windows用户需要使用这个方式
进入pypi.python.org搜索要安装的库的名字，这时候有三种可能：

• 文件是.exe文件，直接一路next
• 文件是.whl文件，好处在于可以自动安装依赖的包
• 源码，大概是zip、tar.zip、tar.bz2格式的压缩包，这个方法要求用户已经安装了这个包所以来的其他包，例如pandas依赖于numpy如果你不安装numpy，这个方法是无法成功安装pandas的。如果没有前两种文件，只能用第三种

1. .whl

1.命令行输入：
pip3 install wheel
等待执行完成，不能报错
2.从资源管理器确认.whl文件的路径，然后在命令行输入：
cd pathname(注意是包含这个文件的文件夹，不包含这个文件本身）
3. 然后在命令行输入：
pip3 install xxx.whl(.whl文件的完整名）

2. 源码压缩包

1.解压包，进入解压好的文件夹，通常会看见一个setup.py文件。从资源管理器中确认你下载文件的路径，打开命令行，输入：
cd pathname(所在文件夹）
2.在命令行下继续输入：
python3 setup.py install

想要卸载库的时候，找到python路径，然后进入site-packages文件夹，在里面删除库文件就可以了