1.注释：
1.单行注释 # 后面加空格 快捷键（ctr+/)
2.多行注释 """ %%%% """
2.变量：
1.赋值存储数据。
2.变量的语法： 变量名 = 变量值（数据）
3.遇到符号（+-*/=等），左右两边都需要空格。
3.命名规范：
1. 英文，数字和下划线组成。不能以数字开头，不能与关键字重名。
2. 多个英文组成，可用下划线连接(my_python)；或用小驼峰命名(myPython)
扩展：小驼峰：第⼀个单词以⼩写字⺟开始，后续单词的⾸字⺟⼤写
（ firstName 、lastName ）
大驼峰：每⼀个单词的⾸字⺟都采⽤⼤写字⺟
（ FirstName、LastName )
4. 查看关键字：
通过以下命令可以查看 Python 中的关键字
[1]: import keyword
[2]: print(keyword.kwlist)
5.变量类型
# String ——字符串
# 布尔类型 —— True / False
- 真 True 数字运算时对应的是 1
- 假 False 数字运算时对应的是 0
# Number (数字）—— int(有符号整型）/ long(长整型）/ float(浮点型）/ complex(复数）
# List (列表）
# Tuple (元组）
# Dictionary (字典）
6. 输出
# 普通输出：
print('hello world')
# 格式化输出
age = 10
print('我今年%d岁' % age)
**常用的格式符号
下面是完整的，它可以与％符号使用列表:
| 格式符号 | 转换 |
|---|---|
| %c | 字符 |
| %s | 字符串 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写字母0x） |
| %X | 十六进制整数（大写字母0X） |
| %f | 浮点数 |
| %e | 科学计数法（小写'e'） |
| %E | 科学计数法（大写“E”） |
| %g | ％f和％e 的简写 |
| %G | ％f和％E的简写 |
# format 格式化函数 （基本语法是通过 {} 和 : 来代替以前的 % 。）
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
#format() 格式化数字
a = 5.026
print(format(a, '.2f')) # 5.03
print(format(a, '.0f')) # 5# 换行输出 （ \n ）
print("1234567890-------") # 会在一行显示
print("1234567890\n-------") # 一行显示1234567890，另外一行显示-------7.输入
# python 2 中使用： raw_input()
password = raw_input("请输入密码:")
print('您刚刚输入的密码是:%d' % password)# python 3 中使用： input()
userName = input('请输入用户名:')
print("用户名为：%s" % userName)## input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存
8. 运算符
# 算术运算符：
下面以a=10 ,b=20为例进行计算
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 两个对象相加 a + b 输出结果 30 |
| - | 减 | 得到负数或是一个数减去另一个数 a - b 输出结果 -10 |
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200 |
| / | 除 | b / a 输出结果 2 |
| // | 取整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| % | 取余 | 返回除法的余数 b % a 输出结果 0 |
| ** | 指数 | a**b 为10的20次方， 输出结果 100000000000000000000 |
注意：混合运算时，优先级顺序为：
**高于*/%//高于+-，为了避免歧义，建议使用()来处理运算符优先级。并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。
>>> 10 + 5.5 * 2
21.0
>>> 10 + (5.5 * 2)
21.0# 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值运算符 | 把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7 |
# 复合赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | 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=3,b=3，则（a == b) 为 True |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | 如a=1,b=3，则(a != b) 为 True |
| > | 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 | 如a=7,b=3，则(a > b) 为 True |
| < | 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 | 如a=7,b=3，则(a < b) 为 False |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3，则(a >= b) 为 True |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3，则(a <= b) 为 True |
# 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 | True and False， 返回 False。 |
| or | x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 | False or True， 返回 True。 |
| not | not x | 布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not True 返回 False, not False 返回 True |
and : 左右表达式都为True，整个表达式结果才为 True
or : 左右表达式有一个为True，整个表达式结果就为 True
not：将右边表达式的逻辑结果取反，Ture变为False，False变为True9. 常用的数据类型转换
| 函数 | 说明 |
|---|---|
| int(x [,base ]) | 将x转换为一个整数 |
| float(x ) | 将x转换为一个浮点数 |
| complex(real [,imag ]) | 创建一个复数，real为实部，imag为虚部 |
| str(x ) | 将对象 x 转换为字符串 |
| repr(x ) | 将对象 x 转换为表达式字符串 |
| eval(str ) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s ) | 将序列 s 转换为一个元组 |
| list(s ) | 将序列 s 转换为一个列表 |
| chr(x ) | 将一个整数转换为一个Unicode字符 |
| ord(x ) | 将一个字符转换为它的ASCII整数值 |
| hex(x ) | 将一个整数转换为一个十六进制字符串 |
| oct(x ) | 将一个整数转换为一个八进制字符串 |
| bin(x ) | 将一个整数转换为一个二进制字符串 |
>>> # eval(): 将字符串形式的数据，转换为原本的类型
... str1 = "3.14"
>>> print(type(eval(str1)))
<class 'float'>10. 判断语句
# if-else的使用格式
if 条件:
满足条件时要做的事情1
else:
不满足条件时要做的事情1# 多个判断条件 if - elif - else
if 性别为男性:
输出男性的体重
...
elif 性别为女性:
输出女性的体重
...
else:
第三种性别的体重
...11. 三目运算法(只适用于一些简单的if,else 判断)
max = a if a >b else b
# max = 当if满足之后得到的结果;else,当if 不满足得到的结果.
（如果 a > b的条件成立,三目运算的结果是a,否则就是b）
12. 循环语句
## 1.while循环
三个关键步骤: 一.初始值变量
二.循环的次数或者条件
三.循环的增量 (一般放在while的下一个Tab)
计算1~100的累积和（包含1和100）
i = 1
sum = 0
while i <= 100:
sum = sum + i
i += 1
print("1~100的累积和为:%d" % sum)
## 2. for 循环
for 临时变量 in 列表或者字符串等可迭代对象:
循环满足条件时执行的代码name = 'itheima'
for x in name:
print(x)
输出结果 ：i t h e i m a
demo
# range(5) 迭代器，range(5)表示可以循环5次即可
for i in range(5):
print(i)
'''
效果等同于 while 循环的：
i = 0
while i < 5:
print(i)
i += 1
'''## break的作用：立刻结束break所在的循环
## continue的作用：用来结束本次循环，紧接着执行下一次的循环
### break/continue只能用在循环中，除此以外不能单独使用; break/continue在嵌套循环中，只对最近的一层循环起作用
13. 容器：字符串，列表，元组，字典
# # 切片 ：对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。
name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
op: abc
# 步长：
name[1::2] # 2 就是步长 意思是从索引为 1 的元素开始 每隔2个元素取一次元素
op： bdf
# 索引：
name[0]
op: a## 字符串，字典，列表，元组的常见操作：
字符串的常见操作:
1. find : mystr.find(str, start=0, end=len(mystr)) ---- 不接受关键字参数，示例： mystr.find(str, 0, 2)
检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
2. index : mystr.index(str, start=0, end=len(mystr)) ---- 不接受关键字参数，示例： mystr.index(str, 0, 2)
跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
3. count : mystr.count(str, start=0, end=len(mystr))
返回 str在start和end之间 在 mystr里面出现的次数
4. replace : mystr.replace(str1, str2, mystr.count(str1))
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
5. split : mystr.split(str,maxsplit) 返回分割后的字符串列表( 字符串转列表 )
name = "hello world ha ha"
name.split(" ")
输出 ：['hello','world','ha','ha']
name.split(" ", 2)
输出 ：['hello','world','ha ha']
str5 = "a,b,c,d"
list(str5):
输出： ['a', ',', 'b', ',', 'c', ',', 'd']
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
# 如果将一串字符串单个切割出来，使用 list(mystr)
6. title : mystr.title()
把字符串的每个单词首字母大写
7. startswith : mystr.startswith(str)
检查字符串是否是以 str 开头, 是则返回 True，否则返回 False
8. endswith : mystr.endswith(obj)
检查字符串是否以obj结束，如果是返回True,否则返回 False.
9. lower : mystr.lower()
转换 mystr 中所有大写字符为小写
10. upper : mystr.upper()
转换 mystr 中的小写字母为大写
11. strip : mystr.strip()
删除mystr字符串两端的空白字符
12. join : str.join(mylist)
以 str 去拼接 mylist,组成一个字符串。
>>> str="_"
>>> mylist=["my","lucky","girl"]
>>> str.join(mylist)
'my_lucky_girl'
列表的相关操作：
1. 添加元素
1. append : list.append(num)
通过append可以列表list 中添加元素num
2. extend : list1.extend(list2)
通过extend可以将另一个集合中的元素逐一添加到列表中
3. insert : list.insert(index,object)
insert(index, object) 在指定位置index前插入元素object
2. 修改元素 ：列表[索引] = “123” : 按照索引值修改，没有此数据会报错
3. 查找元素 ： in, not in --》 查找指定的元素是否存在
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#查找是否存在
if findName in nameList:
print('在字典中找到了相同的名字')
else:
print('没有找到') 4. index , count
列表[索引] : 根据索引取值，索引不存在会报错 IndexError。
#列表的切片，索引超出个数，不会产生生IndexError，而是仅仅返回一个空列表。
列表.index(数据) : 返回数据第一次出现的索引，没有查到会报错
列表.count(数据) : 数据在列表中出现的次数
len(列表) : 列表中数据的个数
5. 删除元素 ： （"删" del,pop,remove)
del 列表[索引] 删除指定索引的数据
列表.remove(数据) 删除第一个出现的数据
列表.pop() 删除末尾数据,有返回值，返回被删除的
列表.pop(索引) 删除指定索引数据,有返回值。 索引不存在，会报错
列表.clear() 清空列表
6. 排序 : (sort, reverse) ： 列表的内存地址保持不变
list.sort() : 将 list 按照顺序排列，默认是从小到大； 不需要参数去接收
list.sort(reverse=True) : 可改为倒序，从大到小
列表.reverse() ： 反转；对原始列表改变
列表[::-1] : 反转；生成新的列表
元祖的相关操作： 元组的元素不能修改。元组使用小括号，列表使用方括号。
1. len 计算元组中元素的个数
2. del 删除 （元素对象不支持删除，但是可以删除整个元组变量）
3. count ： 统计元素在元组中个数 tuple1.count('b')
4. index 返回元素第一次出现的位置索引 tuple1.index('b')
字典的常见操作 : dict1 = {“键”:”值”, “键”:”值”}
1. 查询 :
字典[键] : 根据键取值，键值对不存在会报错
字典.keys() : 通过遍历使用，获取所有的键
字典.values() : 通过遍历使用，获取所有值
字典.items() : 通过遍历使用，获取所有(键，值)，需要两个遍历变量
字典.get( 键 ) # 获取不存在的 key, 会获取到空的内容，不会出现异常
2. 修改
字典[键] = 数据 : 有这个键会修改，没有会增加
字典.setdefault(键，数据) ： 键 不存在，添加键值对； 键 存在 则不做处理
字典1.update(字典2) : 取出字典2的键值对。字典1中 键 存在，则修改值；不存在，添加键值对；
3. 删除
del 字典[键] : 删除指定的键值对
字典.pop(键) : 删除指定键值对,返回被删除的值
字典.clear() : 清空字典
4. 增加
字典[“键”] = “123” ： 没有这个键会增加，有这个键会修改
# 字典的常见操作：
<1> len()
获取字典中，键值对的个数、
dict = {"name":"zhangsan","sex":"man"}
len(dict)
>>> 2
----------------------- 下面几个为 pyton2 的输出-------------------------
<2> keys()
返回一个包含字典所有 key的列表
dict.keys()
>>> ['name','sex']
<3> values()
返回一个包含字典所有 value 的列表
dict.values()
>>> ['zhangsan','man']
<4> items()
返回一个包含所有（键：值）元组的列表
dict.items()
>>> [('name','zhangsan'),('sex','man')]
----------------------------------------------------------------------
""" 字典的操作 """
information = {"name": "张三", "age": 18, "content": "此人很厉害"}
# print(type(information))
# 查询
print(information['name'])
print(information.get('ages'))
key =information.keys()
print(key)
# dict_keys(['name', 'age', 'content'])
# 在 Python 2.x 中，这三个方法的返回值是列表类型。但在 Python 3 中，并不是我们常见的
#列表和元组类型，因为 Python 3不希望用户直接操作这几个方法的返回值。
# 方法一 ： 使用 list() 函数，将它们返回的数据转换成列表
key_list = list(key)
print(key_list)
# 方式二： 利用 for 循环获取 key 列表
key_for = []
for i in key:
key_for.append(i)
print(key_for)
集合的操作： set 用{}表示，可存储多个数据，数据不重复；
1.快速去除列表中的重复元素
a = [11,22,33,33,44,22,55]
set(a)
2.集合 a, b
a = {11,22,33,44,55}
b = {22,44,55,66,77}
1) 交集：共有的部分
a&b --> {22, 44, 55}
2) 并集：总共的部分
a | b --> {11, 22, 33, 44, 55, 66, 77}
3) 差集：另一个集合中没有的部分
b - a --> {66, 77}
4) 对称差集(在a或b中，但不会同时出现在二者中/ 两者总共的和 - 两者的共有的部分)
a ^ b --> {11, 33, 66, 77}
遍历 ： 通过 for ... in ... 可以遍历字符串，列表，元祖，字典等；
1. 字符串遍历
>>> a_str = "hello itcast"
>>> for char in a_str:
... print(char,end=' ')
...
h e l l o i t c a s t
2. 列表遍历
>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
... print(num,end=' ')
...
1 2 3 4 5
3. 元组遍历
>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
... print(num,end=" ")
1 2 3 4 5
4. 字典遍历
dict = {'name':'zhangsan', 'sex':'man'}
<1> 遍历字典的 key（键）
for key in dict.keys():
print key
....
name
sex
....
<2> 遍历字典的 value (值）
for value in dict.values():
print value
....
zhangsan
man
....
<3> 遍历字典的项 （元素）
for item in dict.items():
print item
....
('name','zhangsan')
('sex','man')
....
<4> 遍历字典的 key-value (键值对）
for key,value in dict.items():
print("key=%s,value=%s"%(key,value))
....
key = name, value = zhangsan
key = sex , value = man
....
5. 如何实现带下标索引的遍历
>>> chars = ['a', 'b', 'c', 'd']
>>> i = 0
>>> for chr in chars:
... print("%d %s"%(i, chr))
... i += 1
...
0 a
1 b
2 c
3 d
6. enumerate()
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合
为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
... print i, chr
...
0 a
1 b
2 c
3 d公共方法：
1. 运算符：
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 复制 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
## 注意 ： in 在对字典操作时，判断的是字典的键。
dict1 = {'a': 'aa', 'b': 'bb', 'c': 'cc'}
# 判断 key 是否存在
if 'a' in dict1.keys():
print('true')
else:
print('false')
# 判断value 是否存在
if 'bb' in dict1.values():
print('true')
else:
print('false')
240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
