age = 8
print("C语言中文网已经%d岁了！" % age)

name = "C语言中文网"
age = 8
url = "http://c.biancheng.net/"
print("%s已经%d岁了，它的网址是%s。" % (name, age, url))

exp1 if contion else exp2

0  1  2  3  4  5...n 索引从左往右
-n -(n-1) -(n-2) -(n-3)...-1  负数从右向左

（abdce）
正数：str[1]=b
负数：str[-1]=e
也就是起始位，正数与负数不同

访问一定范围的序列
#列表的创建用 []，后续讲解列表时会详细介绍
list = [None]*5
print(list)

使用 in 关键字检查某元素是否为序列的成员
str="c.biancheng.net"
print('c'in str)

str="c.biancheng.net"
#找出最大的字符
print(max(str))
#找出最小的字符
print(min(str))
#对字符串中的元素进行排序
print(sorted(str))

[element1, element2, element3, ..., elementn]

num = [1, 2, 3, 4, 5, 6, 7]
name = ["C语言中文网", "http://c.biancheng.net"]
program = ["C语言", "Python", "Java"]

nulllist=[] //列表可以为空

list()函数创建列表
#将字符串转换成列表
list1 = list("hello")
print(list1)

#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)

#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

#创建空列表
print(list())

result
['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]

del listname

testlist=[1,2,3,4]
del testlist
print(testlist)  //报错

a=[1]
b=[2]
c=a+b
print(c)
> 1,2

Python append()方法添加元素：
append() 方法用于在列表的末尾追加元素,obj 添加到列表末尾的数据
listname.append(obj)
l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)

#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)

#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)

Python extend()方法添加元素;
extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中
实例
l = ['Python', 'C++', 'Java']
#追加元素
l.extend('C')
print(l)
#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)
#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)

Python insert()方法插入元素：
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。
实例
l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)
#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)
#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)
#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://c.biancheng.net")
print(l)
值得一提的是，插入的是元组的话，会有括号

del命令：不仅可以删除整个列表，还可以删除列表中的某些元素。

#删除单个元素:del listname[index]
attention！！！ index 表示元素的索引值。

#删除中间连续元素:del listname[start : end]
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[1: 4]
print(lang)

#pop()：根据索引值删除元素:listname.pop(index)
注意！如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”，“出队”操作

#remove()：根据元素值进行删除：listname.remove(number)
remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

#clear()：删除列表所有元素:listname.clear()
#也可以是  del listname[:]

#修改单个元素：listname[index]=修改值
index仍然是索引值
a=[2]
a[0]=1
print(a)
执行后：a=1

#修改一组元素：listname[start:end]=[x,x,...,x]
与上start：end同意思

#也可以用于插入元素:listname[index:index]=[x,x,...,x]
等于在index位置插入一组元素，切片语法，对空切片赋值。

#切片语法指定步长
nums = [40, 36, 89, 2, 36, 100, 7]
#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)
执行：
[40, 0.025, 89, -99, 36, 20.5, 7]

index() 方法用来查找某个元素在列表中出现的位置（也就是索引）；
如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。
用法：
listname.index(obj, start, end)
解读参数：
obj表示将进行操作的元素
start 和 end 参数用来指定检索范围：
start 和 end 可以都不写，此时会检索整个列表；
如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。
实例：
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
#检索列表中的所有元素
print( nums.index(2) )
#检索3~7之间的元素
print( nums.index(100, 3, 7) )
#检索4之后的元素
print( nums.index(7, 4) )
#检索一个不存在的元素
print( nums.index(55) )
执行：
3
5
6
Traceback (most recent call last):
    File "D:x/x/x/x.py", line 9, in <module>
        print( nums.index(55) )
ValueError: 55 is not in list

count() 方法用来统计某个元素在列表中出现的次数: listname.count(obj)
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
#统计元素出现的次数
print("36出现了%d次" % nums.count(36))
#判断一个元素是否存在
if nums.count(100):
    print("列表中存在100这个元素")
else:
    print("列表中不存在100这个元素")
执行
36出现了3次
列表中存在100这个元素

添加元素
'+'：c=a+b时，c的内存地址与a和b均不一，是重新生成的。
extend： 处理列表后，没有返回值，故不可以使用链式表达式，也就是extend不可以放在等号右边，必须在左边，符合这个要求，extend和'+'生成的内容一致，但是extend不会重新创建一个a，而是改变a的内容，故extend效率较高。
append： 将b作为一个整体追加到a后面，也就是带一个中括号，与上述两种功能不同，注意区别。

删除元素
需要注意的是使用del删除元素的时候，主要删除的是变量还是数据
实例
tt = 'hello'
#定义一个包含多个类型的 list
list1 = [1,4,tt,3.4,"yes",[1,2]]
l2 = list1
print(id(l2),id(list1))
del list1
print(l2)
print(list1)
执行
1765451922248 1765451922248
[1, 4, 'hello', 3.4, 'yes', [1, 2]]
Traceback (most recent call last):
  File "D:x/x/x/x.py", line 8, in <module>
    print(list1)
NameError: name 'list1' is not defined
解释
list1的值赋值给了l2，所以删除list1时，打印l2，l2 所指向的内存数据还是存在的，所以删除的list1是删除了变量list1，未删除指定数据

#此时就可以使用 del 关键字来回收内存，解決高并发状态时，无效内存占用。
操作：
#引入gc库
import gc
tt = 'hello'
#定义一个包含多个类型的 list
list1 = [1,4,tt,3.4,"yes",[1,2]]
del list1
#回收内存地址
gc.collect()

 Python 提供了 range() 函数，可帮助我们高效地处理数字列表，即便列表需要包含数百万个元素，也可以快速实现。
 Python range() 函数能够轻松地生成一系列的数字.range() 函数常常和 Python 循环结构、推导式（后续会讲，这里先不涉及）一起使用，几乎能够创建任何需要的数字列表
 实例
 #可以用于生成顺序字典
 for value in range(1,5):   
    print(value)
 执行
1
2
3
4
但是返回值并不是list类型，时range类型，如果需要返回list类型，可以list(range(1,10))，即可
#指定步长
实例
even_numbers = list(range(1,11,2))
print(even_numbers)
执行
[1, 3, 5, 7, 9]

queue=[]
queue.insert(0,1)
queue.insert(0,2)
queue.insert(0,3)
print(queue)
print(queue.pop())
print(queue.pop())
print(queue.pop())
print(queue)
执行
[3,2,1]
1
2
3
[]
实现队列先进先出

stack=[]
stack.append(1)
stack.append(2)
stack.append(123123131)
print(stack)
print(stack.pop())
print(stack.pop())
print(stack.pop())
执行
[1, 2, 123123131]
123123131
2
1
实现先进后出，栈的功能

from collecions import deque

使用 ( ) 直接创建
tuplename = (element1, element2, ..., elementn)
实例
course = "Python教程", "http://c.biancheng.net/python/"
print(course)
执行
('Python教程', 'http://c.biancheng.net/python/')

使用tuple()函数创建
tuple(data)
实例
#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)

#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)

#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)

#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)

#创建空元组
print(tuple())
执行
('h', 'e', 'l', 'l', 'o')
('Python', 'Java', 'C++', 'JavaScript')
('a', 'b', 'c')
(1, 2, 3, 4, 5)
()

tuplename[index]
indexi 表示索引值。元组的索引可以是正数，也可以是负数。

因为元组为不可变序列，估所以我们只能创建一个新的元组去替代旧的元组。

与上同，只能通郭del全部删除
del tuplename

#使用 { } 创建字典
dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
Point：字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。

#通过 fromkeys() 方法创建字典
使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典
dictname = dict.fromkeys(list，value=None)
实例
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 100)
print(scores)
执行
{'语文': 100, '数学': 100, '英语': 100}

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。

#dictname[key] //键必须是存在的，否则会抛出异常。
实例
tup = (['two',26], ['one',88], ['three',100], ['four',-59])
dic = dict(tup)
print(dic['one'])  #键存在
print(dic['five'])  #键不存在
执行
88
Traceback (most recent call last):
    File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in <module>
        print(dic['five'])  #键不存在
KeyError: 'five'

#Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。
dictname.get(key[,default])
实例
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
执行
88

使用 del 关键字
Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。

#Python字典添加键值对
dictname[key] = value
实例
a={'math':10000}
print(a)
a['chinese']=10023 //新建一个键，指定一个值
print(a)
执行
{'math': 10000}
{'math': 10000, 'chinese': 10023}

#Python字典修改键值对
实例
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
a['语文'] = 100 //在原有的值上改变值
print(a)
执行
{'数学': 95, '语文': 89, '英语': 90}
{'数学': 95, '语文': 100, '英语': 90}

#Python字典删除键值对
del语句
实例
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
执行
{'英语': 90}

#判断字典中是否存在指定键值对
print('str/元素' in dictname)

实例
# 字符串模板中使用key
temp = '教程是：%(name)s, 价格是：%(price).2f, 网址是：%(url)s'
course = {'name':'Python教程', 'price': 9.9, 'url': 'http://c.biancheng.net/python/'}
# 使用字典为字符串模板中的key传入值
print(temp % course)
course = {'name':'C++教程', 'price':15.6, 'url': 'http://c.biancheng.net/cplus/'}
# 使用字典为字符串模板中的key传入值
print(temp % course)
执行
教程是：Python教程, 价格是：9.90, 网址是：http://c.biancheng.net/python/
教程是：C++教程, 价格是：15.60, 网址是：http://c.biancheng.net/cplus/

在Python3.x版本返回的类型都不是list类型，因为Python 3.x 不希望用户直接操作这几个方法的返回值。但是2.x版本是返回list类型
若在3.x版本需要更改返回类型：
#使用list()转换成列表
b=list(a.key())

#使用 for in 循环遍历它们的返回值
实例
a = {'数学': 95, '语文': 89, '英语': 90}
for k in a.keys():
    print(k,end=' ')
print("\n---------------")
for v in a.values():
    print(v,end=' ')
print("\n---------------")
for k,v in a.items():
    print("key:",k," value:",v)
 执行
 数学 语文 英语
---------------
95 89 90
---------------
key: 数学  value: 95
key: 语文  value: 89
key: 英语  value: 90
中间的k,v不可被替换

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典
深浅拷贝
举例
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，因此 a 添加新键值对，不会影响 b。
a['four']=100
print(a)
print(b)
#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
a['three'].remove(1)
print(a)
print(b)
执行
{'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 100}
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
{'one': 1, 'two': 2, 'three': [2, 3], 'four': 100}
{'one': 1, 'two': 2, 'three': [2, 3]}

#常见的浅拷贝的方法，是使用数据类型本身的构造器
#对于可变的序列，还可以通过切片操作符“：”来完成浅拷贝
#Python 还提供了对应的函数 copy.copy() 函数，适用于任何数据类型。
注意：对于元组，使用 tuple() 或者切片操作符 ':' 不会创建一份浅拷贝，相反它会返回一个指向相同元组的引用

#Python 中以 copy.deepcopy() 来实现对象的深度拷贝。
注意：如果被拷贝对象中存在指向自身的引用，那么程序很容易陷入无限循环。

使用一个字典所包含的键值对来更新己有的字典；
在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。
实例
a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':4.5, 'four': 9.3})
print(a)
执行
{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}

二者都是用来删除字典中的键值对；
不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：
dictname.pop(key)
dictname.popitem()
实例
a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
print(a)
a.pop('化学')
print(a)
a.popitem()
print(a)
执行
{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98}
popitem() 随机删除字典中的一个键值对是不准确的，虽然字典是一种无须的列表，但键值对在底层也是有存储顺序的，popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似，都实现了数据结构中“出栈”的操作。

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：
dictname.setdefault(key, defaultvalue)
当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。所以总结：

{element1,element2,...,elementn}

#使用 {} 创建
setname = {element1,element2,...,elementn}

#set()函数创建集合
set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下

setname = set(iteration)  //iteration 就表示字符串、列表、元组、range 对象等数据。

#最常用循环结构，逐一读取
实例
a = {1,'c',1,(1,2,3)}
for ele in a:
    print(ele,end=' ')
 执行
 1 c (1, 2, 3)

#同样的使用del()元素

#使用add()函数实现
setname.add(element)

#remove()，如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误
#discard()，不会报错，即使元素不在set集合内
setname.remove(element)
实例
a = {1,2,3}
a.remove(1)
print(a)
a.discard(1)
print(a)
执行
{2, 3}
{2, 3}

实例
s = {'Python', 'C', 'C++'}
fs = frozenset(['Java', 'Shell'])
s_sub = {'PHP', 'C#'}
#向set集合中添加frozenset
s.add(fs)
print('s =', s)
#向为set集合添加子set集合
s.add(s_sub)
print('s =', s)
执行
s = {'Python', frozenset({'Java', 'Shell'}), 'C', 'C++'}
Traceback (most recent call last):
    File "D:\xxx\xxx\xx\xx.py", line 11, in <module>
        s.add(s_sub)
TypeError: unhashable type: 'set'

实例
dic = {"name":111}
print(hash("name"))
setDemo = {1}
print(hash(1))
执行
8156012332694087136
1

strname = "str1" "str2"   //str'_'为内容
strname = str1+str2  //str'_'为变量

借助 str() 和 repr() 函数将数字转换为字符串，它们的使用格式为：
str(obj)
repr(obj)
实例
name = "C语言中文网"
age = 8
course = 30
info = name + "已经" + str(age) + "岁了，共发布了" + repr(course) + "套教程。"
print(info)
执行
C语言中文网已经8岁了，共发布了30套教程。

strname[index]

strname[start : end : step]
三个都可以省略，但是每次必须留一个作为参数

>>> a='http://c.biancheng.net'
>>> len(a)
22

str.split(sep,maxsplit)
str：表示要进行分割的字符串；
sep：用于指定分隔符，可以包含多个字符。此参数默认为 None，表示所有空字符，包括空格、换行符“\n”、制表符“\t”等。
maxsplit：可选参数，用于指定分割的次数，最后列表中子串的个数最多为 maxsplit+1。如果不指定或者指定为 -1，则表示分割次数没有限制。

newstr = str.join(iterable)
此方法中各参数的含义如下：
newstr：表示合并后生成的新字符串；
str：用于指定合并时的分隔符；
iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。

str.count(sub[,start[,end]])
此方法中，各参数的具体含义如下：
str：表示原字符串；
sub：表示要检索的字符串；
start：指定检索的起始位置，也就是从什么位置开始检测。如果不指定，默认从头开始检索；
end：指定检索的终止位置，如果不指定，则表示一直检索到结尾。

str.find(sub[,start[,end]])
此格式中各参数的含义如下：
str：表示原字符串；
sub：表示要检索的目标字符串；
start：表示开始检索的起始位置。如果不指定，则默认从头开始检索；
end：表示结束检索的结束位置。如果不指定，则默认一直检索到结尾。

str.index(sub[,start[,end]])
此格式中各参数的含义分别是：
str：表示原字符串；
sub：表示要检索的子字符串；
start：表示检索开始的起始位置，如果不指定，默认从头开始检索；
end：表示检索的结束位置，如果不指定，默认一直检索到结尾。

输出对齐，皆有参考

str.startswith(sub[,start[,end]])
此格式中各个参数的具体含义如下：
str：表示原字符串；
sub：要检索的子串；
start：指定检索开始的起始位置索引，如果不指定，则默认从头开始检索；
end：指定检索的结束位置索引，如果不指定，则默认一直检索在结束。

>>> str = "c.biancheng.net"
>>> str.startswith("c")
True

str.endswith(sub[,start[,end]])
此格式中各参数的含义如下：
str：表示原字符串；
sub：表示要检索的字符串；
start：指定检索开始时的起始位置索引（字符串第一个字符对应的索引值为 0），如果不指定，默认从头开始检索。
end：指定检索的结束位置索引，如果不指定，默认一直检索到结束。

>>> str = "c.biancheng.net"
>>> str.endswith("net")
True

title() 方法的语法格式如下：
str.title()

>>> str = "c.biancheng.net"
>>> str.title()
'C.Biancheng.Net'
>>> str = "I LIKE C"
>>> str.title()
'I Like C'

lower() 方法的语法格式如下：
str.lower()

>>> str = "I LIKE C"
>>> str.lower()
'i like c'

upper() 方法的语法格式如下：
str.upper()

>>> str = "i like C"
>>> str.upper()
'I LIKE C'

Python 中，字符串变量提供了 3 种方法来删除字符串中多余的空格和特殊字符，它们分别是：
strip()：删除字符串前后（左右两侧）的空格或特殊字符。
lstrip()：删除字符串前面（左边）的空格或特殊字符。
rstrip()：删除字符串后面（右边）的空格或特殊字符。

strip() 方法用于删除字符串左右两个的空格和特殊字符，该方法的语法格式为：
str.strip([chars])

lstrip() 方法用于去掉字符串左侧的空格和特殊字符。该方法的语法格式如下：
str.lstrip([chars])

rstrip() 方法用于删除字符串右侧的空格和特殊字符，其语法格式为：
str.rstrip([chars])

http://c.biancheng.net/view/4301.html
总的来说，就是统一格式再统一输出，记住参数以及语法即可。

http://c.biancheng.net/view/4305.html
encode() 方法的语法格式如下：
str.encode([encoding="utf-8"][,errors="strict"])

decode() 方法的语法格式如下：
bytes.decode([encoding="utf-8"][,errors="strict"])

Python dir() 函数用来列出某个类或者某个模块中的全部内容，包括变量、方法、函数和类等，它的用法为：
dir(obj)
obj 表示要查看的对象。obj 可以不写，此时 dir() 会列出当前范围内的变量、方法和定义的类型。

help(obj)

def 函数名(参数列表):
    //实现特定功能的多行代码
    [return [返回值]]

[返回值] = 函数名([形参值])

首先，对于调用空函数来说，由于函数本身并不包含任何有价值的执行代码，也没有返回值，应该调用空函数不会有任何效果。

#定义一个比较字符串大小的函数
def str_max(str1,str2):
    '''
    比较 2 个字符串的大小
    '''
    str = str1 if str1 > str2 else str2
    return str
help(str_max)
#print(str_max.__doc__)

datetime类（使用replace取消部分数值输出（print），数值仍存在，但是不会影响.second等计算时间差函数使用）

__init__函数：两个下划线开头的函数是声明该属性为私有，也称之为初始化函数
__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。

pip install scrapy