《编程小bai的第一本Python入门书》笔记

Python学习

1、字符串

num = 1
string = '1'
print(num + string)
#上面代码会报错：不同的数据类型不能进行合并。

如果不知道变量什么类型，可以使用type()函数来查看类型

print(type(word))

字符串的分片与索引

name = ‘my name is mike’

print(name[0]) #'m'
print(name[-4]) #'m'
print(name[11:14]) #'mik' 14th one is excluded
print(name[11:15])	#'mike'
print(name[5:])	#'me is mike'
print(name[:5]) #'my na'

注：空格也算一位

字符串的方法

请看代码：

phone_number = '1386-666-0006'
hiding_number = phone_number.replace(phone_number[:9], '*' * 9)
print(hiding_number) #*********0006

replace(被替换的字符串，将要换成的字符)：字符串替换方法

search = '168'
num_a = '1386-168-0006'
num_b = '1681-222-0006'
print(search + ' is at ' + str(num_a.find(search)) + ' to ' + str(num_a.find(search)) + len(search) + ' of num_a') #168 is at 5 to 8 of num_a
print(search + ' is at ' + str(num_b.find(serch)) + ' to ' + str(num_b.find(search)) + len(search) + 'of num_b') #168 is at 0 to 3 of num_b

’str’.find(search):

• str为被搜索的字符串
• search为目标字符串
• return：目标字符串在被搜索字符串中的起始下标

字符串格式符

当字符串中有多个空时，可以使用**.format()**进行处理

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

2、函数（方法）

print() #输出函数
input() #用户输入信息函数
len() #测量一个对象的长度
int() #将字符串类型的数字转换成整数类型的数字

Python官网函数介绍

以下是自定义函数：

def functionName(arg1, arg2):
    do something.....
	return 'Something'

return：返回值（option）

如果输出一个没有返回值的函数，不会报错，只不过会打印出None。因为就会返回None。

传递参数与参数类型

传递参数有两种方式：

• 位置参数
• 关键词参数

def trapezoid_area(base_up, base_down, height):
	return 1 / 2 * (base_up, base_down) * height

位置参数

trapezoid_area(1,2,3)

参数一一对应被称作位置参数

关键词参数

trapezoid_area(base_up = 1, base_down = 2, height = 3) #right
trapezoid_area(height = 3, base_down = 2, base_up = 1) #right
trapezoid_area(height = 3, base_down = 2, 1) #wrong
trapezoid_area(base_up = 1, base_down = 2, 3) #right
trapezoid_area(1, 2, height = 3) #right

总之：写了关键词的参数，无所谓顺序。没有关键词的参数，就是按位置参数传。不论怎么转值，每个参数不能冲突和漏写才能使用函数。

默认参数

给一个参数设置默认值非常简单，只需要定义参数的时候给参数赋值即可

def trapezoid_area(base_up, base_down, height = 3):
	return 1 / 2 * (base_up, base_down) * height

这样的话可以使用两个参数了

trapezoid_area(1,2)

Python自带的函数print()也是自带默认参数sep=’ '，我们可以重新传入**‘\n’**换行

符号	描述
*	乘——两个数相乘或是返回一个被重复若干次的字符串
/	除—— x 除以 y
%	取模——返回除法的余数
**	幂——返回x的y次幂
//	取整数——返回商的整数部分（9//2的结果是4，9.0//2.0的结果是4.0）

3、循环和判断

基础比较

布尔值：True和False

1 > 2 #False
1 < 2 < 3 #True
42 != '42' #True
'Name' == 'name' #False
'M' in 'Magic' #True
number = 12
number is 12 #True

#函数产生结果的比较(结果等价于 10 > 19)
abs(-10) > len('length of this word')

比较运算的小问题

不同对象不可以使用"<,>,<=,>=“进行比较，却可以使用”=="和“!=”

42 > 'the answer' #不能比较
42 == 'the anser' #False
42 != 'the anser' #True

注：浮点和整数虽不同类型，但是可以比较

5.0 == 5 #True
3.0 > 1 #True

布尔类型的比较（True == 1, False == 0）

True > False
True + False > False + False
#上面的等价于下面
1 > 0
1 + 0 > 0 + 0

成员运算符（in）与 身份运算符（is）

把in放在两个对象中间的含义是：测试前者是否存在与in后面的集合中

is操作符进行身份的对比

the_Eddie = 'Eddie'
name = 'Eddie'
the_Eddie == name
the_Eddie is name #True

在Python中任何对象都可以判断布尔值，除了0，None和所有空的序列和集合（列表，字典，集合）的布尔值为False之外，其他的都是True，可以使用**bool()**来判断：

bool(0)
bool([])
bool('')
bool(False)
bool(None)
#以上均为False

当你想设定一个变量时，但是没想好等于什么值时，可以让他为None:

a_thing = None

注：在Python3之后推荐，判断一个对象是否为空（$None$），使用$is、isnot$来编写。

object is None # 不使用object==None
object is not None

布尔运算

运算符	描述
not x	如果x是Ture，则返回False，否则返回True
x and y	并且
x or y	或者

经常用于处理符合条件：

1 < 3 and 2 < 5 #True
1 < 3 or 2 > 5 #True

条件

def account_login():
	password = input('Password:')
	if password == '123456':
		print('Login success!')
	elif condition: #多重判断
		do something
	else:
		print('Wrong password or invalid input')
		account_login()

account_login()

循环

for循环

#格式
for item in iterable:
	do something
    
for num in range(1,11):
    print(str(num) + ' + 1 = ', num + 1)

while循环

while condition:
	do something


while 1 < 3:
	print('1 is smller than 3')

改变条件

• break
• continue

4、数据结构

Python有四种数据结构，分别是：列表、字典、元组、集合。

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

列表（list）

list = [val1, val2, val3, val4]

1. 列表中的每个元素都是可变
2. 列表汇总元素是有序的
3. 列表可以容纳Python中任何对象（可以混合放入）

列表的增删改查

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

inter(index, object)：插入元素的位置是在指定位置元素之前。如果插入的位置在列表中不存在（超出指定范围），则将该元素放入列表最后一位

另外，使用这个方法也能达到“插入”的效果：

fruit[0:0] = ['Orange']
print(fruit)

删除列表元素使用的是remove():

fruit = ['pinapple', 'pear', 'grape']
fruit.remove('grape')
print(fruit)

替换的话可以像数组一样

fruit[0] = 'Grapefruit'

删除可以使用del关键字来声明：

del fruit[0:2]
print(fruit)

注：列表支持持用位置进行索引

列表的切割

list [ param1 : param2 : param3 ]中有三个参数

• param1：表示start_index，可以为空，默认为0。
• param2：表示end_index，可以为空，当前位置不会被取到，默认为list.size
• param3：表示步长，默认为1。当步长为 -1 时，返回倒序原序列。

字典（dictionary）

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

code = {'BIDU':'Baidu', "SINA":'Sina'}

字典的增删改查

字典没有 “方法” 去添加一个，只能像数组一样：

code['YOKU'] = 'Youku'

可以添加多个元素 update()：

code.update({'FD':'Facebook', 'TSLA':'Testla'})

删除字典的元素使用 del：

del code['FB']

虽然字典使用的是花括号，但是索引内容时使用的是中括号：

code['TSLA']

注：字典不能够切片

字典中的get()函数

语法：dict.get(key,default=None)

参数：

• key–字典中要查找的键
• default–如果指定键的值不存在，则返回该默认值

字典的遍历

• 字典的遍历会取出它的key值：for k in dict
• dict.items()表示：以列表返回可遍历的（键、值）元组数组。
  • 使用方法:for k, v in dict.items()

元组（Tuple）

元组是一个稳固版的列表，不可被修改。只能查找，方式和列表一样。

letters = ('a', 'b', 'c')
letters[0]

集合（set）

和java中的set一样

set = {1, 2, 3, 4}
set.add(5)
set.discard(5) #元素的删除

数据结构的一些技巧

多重循环

排序

语法：sorted(iterable, key=None, reverse=False)

参数说明：

• iterable–可迭代的对象。
• key–主要是用来进行比较的元素，只能有一个参数。就是指定可迭代对象中需要比较的元素是哪个。
• reverse–排序规则，reverse = True为降序，reverse=False为升序（默认）。

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

sorted()函数会按照长短、大小、英文字母的顺序给每个元素排序。但是sorted函数不会改变list列表本身。

使用默认参数reverse会使列表按逆序排列（也不会改变list本身）

sorted(num_list, reverse = True)

在整理列表时，同时使用两个列表。可以用到zip函数，比如：

for a, b in zip(num, str): #a来自于num，b来自于str
	print(b, 'is', a)

注：此时循环次数由num和str中最短的长度决定。

num = [10, 89, '33', 12, 88]
str = '112345'
for a, b in zip(num, str):
	print(a, 'is', b)
#结果
10 is 1
89 is 1
33 is 2
12 is 3
88 is 4

推导式

将十个数装进列表中，普通写法：

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

换成解析式（推导式）就短小些，并且执行效率远远胜过前者：

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

将推导式看成两部分（如下图）：竖线前面的是我们想要放入list中的元素，后面则是循环表达式。

list = [item | for item in iterable]

例子：list的推导

a = [i ** 2 for i in range(1,10)]
b = [n for i in range(1, 10) if n % 2 == 0]
c = [letter.lower() for letter in 'ABCDEFG']

字典也可以推导，并且同时附上key和value

d = [i : i + 1 for i in range(1, 10)]
e = [i : j for i, j in zip(range(1, 6), 'abcde')]
f = [i : j.upper() for i, j in zip(range(1, 6), 'abcde')]

循环列表时获取元素的索引

列表是有序的，可以使用enumerate函数：

letters = ['a', 'b', 'c', 'd']
for num, letter in enumerate(letters):
	print(letter, 'is', num + 1)
#结果
a is 1
b is 2
c is 3
d is 4

5、面向对象编程——类

定义一个类：

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)

#结果
['caffeine', 'sugar', 'water', 'soda']
['caffeine', 'sugar', 'water', 'soda']
['caffeine', 'sugar', 'water', 'soda']

类属性

是类的属性哦。与正常变量并无区别

for element in coke_for_me.formula:
	print(element)
   
#result
caffeine
sugar
water
soda

实例方法

class CocaCola:
	#类属性
	formula = ['caffeine', 'sugar', 'water', 'soda']
	def drink(self):
		print('Emergy!')

coke = CocaCola()
coke.drink()
#result
Emergy!

**此时调用方法，并没有传入参数，但是却可以正常运行？**其实这时传入self参数的是coke对象本身。（self是参数名，可以随意修改，但习惯这么写）

用$java$来类比的话，就相当于$drink$是$CocaCola$类调用的，这个参数self是coke对象。用代码来看：

coke.drink() == CocaCola.drink(coke) #两边写法完全一致

更多参数

类方法也有属于自己的参数

class CocaCola:
	#类属性
	formula = ['caffeine', 'sugar', 'water', 'soda']
	def drink(self, how_much):
		if how_much == 'a sip':
			print('Cool~')
		elif how_much == 'whole bottle':
			print('Headache')

ice_coke = CocaCola()
ice_coke.drink('a sip')

魔术方法（__init__()）

Python类中存在一些“魔术方法”==__init__()==是其中之一。像是java和C++中的构造函数，但是有一个更强大的功能——能够新增实例属性。

class CocaCola:
	#类属性
	formula = ['caffeine', 'sugar', 'water', 'soda']
	def __init__(self):
		self.local_logo = '可口可乐'
	def drink(self):
		print('Emergy!')

coke = CocaCola()
print(coke.local_log)

__init()__可以有自己的参数：

class CocaCola:
	#类属性
	formula = ['caffeine', 'sugar', 'water', 'soda']
	def __init__(self, logo_name):
		self.local_logo = logo_name
	def drink(self):
		print('Emergy!')

coke = CocaCola()
print(coke.local_log)

类的继承

父类（$CocaCola$）：

class CocaCola:
	calories = 140
	sodium = 45
	total_carb = 39
	caffeine = 34
	ingredients = [
		'High Fructose corn Syrup',
		'Carbonated Water',
		'Phosphoric Acid',
		'Natural Flavors',
		'Caramel Color',
		'Caffeine'
	]
	def __init__(self, logo_name):
		self.local_log = logo_name
		
	def drink(self):
		print('YOu got {} cal energy!'.format(self.calories))

子类（$无糖可乐$）：在子类中类名后面的括号放入父类名，就表示继承关系

class CaffeineFree(CocaCola):
	caffeine = 0
	ingredients = [
		'High Fructose Corn Syrup',
		'Carbonated Water',
		'Phosphorice Acid',
		'Natural Flavors',
		'Carmel Color'
	]

coke_a = CaffeineFree('Cocacola-FREE')
coke_a.drink()

父类中的变量和方法完全被子类继承，子类可以覆盖父类的变量和方法。

特殊属性（__dict__）

__dict__是一个字典，用于存储类或者实例属性。即使不去定义它，它也会存在与每个类中。

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

6、使用第三方库

1. 使用pyCharm下载
2. 使用pip下载
3. 手动下配置