Python学习1（变量、语句、字符串）

python编程规范 PEP8
pycharm 格式化 ctrl + alt + l，可以在这里看到一些常用的快捷键
多行注释’‘’ 注释内容 ‘’’

变量声明与类型转换

python是弱语言，变量声明的时候对数据类型不是很严格
格式：变量名 = 值
python建议变量名用下划线
type()查看数据类型
python中变量名更建议用下划线分割单词：变量名，函数名和文件名全小写，使用下划线连接； 类名遵守大驼峰命名法； 常量名全大写；

对于字符串，单引号，双引号都可以，三引号也可以（赋值符号后面）
为什么要有三种形式来表示字符串呢
是为了嵌套引号的时候进行区分
例如 m = " sdfsdf’dfsdf’"

三引号是为了输出保持格式：

python输入的类型都是字符串

# 浮点型直接转整型没问题，小数点后的数字被忽略
a = 9.9
print(int(a)) # 9
# 如果是字符串转成整型就会有问题
a = '9.9'
print(int(a)) # 报错
# 字符串转float可以
a = '9.9'
print(float(a))

# True转整型对应是1，False是0
# True转浮点型是1.0，False是0.0
# 布尔转字符串直接变成字符串
# 只要不是0的数转换成布尔型bool都是true
# 空字符串转('')换成bool是False
print(bool(''))
print(bool(""))
print(bool(0))
print(bool({}))
print(bool([]))
print(bool(()))
print(bool(None))
# 都是false

# 指定输出中的间隔符号
print(1,2,3,sep='#')
# 输出结果
# 1#2#3

end表示结果加什么

运算符

# 多个变量赋值(使用逗号分隔)
>>> num1, f1, str1 = 100, 3.14, "hello"
>>> num1
100
>>> f1
3.14
>>> str1
"hello"

数字和字符串做==运算结果是false,除了 == 以外的逻辑运算时，会直接报错。
如果是两个字符串进行比较，会将每个字符都转换成对应的编码，然后逐一进行对比。

print(80<=90<100)	# True

这里需要注意，当有很多逻辑运算符连接时，需要注意取的是哪一个值
因为这里取逻辑时，也是短路与或者短路或，所以是取最后一个成立的值

a = 1
b = 3
print(a and b) # 输出3，取后面的值
print(a or b) # 输出1，取前面的值
c = 0
print(c and a) # 输出0

a = 34

a > 10 and print('hello world') # 有输出
a < 10 and print('hello world') # 无输出

a >10 or print('你好世界') # 无输出
a <10 or print('你好世界') # 有输出

格式化输出

关于格式化输出，保留多少位小数输出

money = 99.56
print('我挣了%f块钱' %money)
# out: 我挣了99.560000块钱
# 可以看到这里有很多不必要的零
print('我挣了%.2f块钱' %money)
# 这里会五舍六入
money = 99.55
print('我挣了%.1f块钱' %money)
# 我挣了99.5块钱
money = 99.56
print('我挣了%.1f块钱' %money)
# 我挣了99.6块钱

进制转换

bin()，oct()，hex()
0b,0o,0x

# 转二进制
n = 149
r = bin(n)
print(r) # 0b10010101

# 转8进制
r = oct(n)
print(r) # 0o225

# 转16进制
r = hex(n)
print(r) # 0x95

# 默认输出十进制
n = 0x558
print(oct(n)) # 0o2530

# 或者用int转换
r = int(n) # 1368

位运算

这里需要注意左移不会溢出，会一直变大

运算符优先级

条件语句

random.randint(1, 10) 产生1到10的随机数（1和10都包含）

pass关键字 是为了支撑结构，比如if写了条件没写内容会报错，称为坍塌的结构，写个pass就可以支撑起这个结构，不至于报错

在Python中允许类似于 5<a<10 的写法
在Python中，转换成为布尔值时，只有 0,“”,‘’,None,(),{},[] 会被转换成为False,其他都会被转换成为True
三元运算符

a = 10
b = 30
c = a if a>b else b

相当于

a = 10
b = 30
if a > b:
    c = a
else:
    c = b

循环语句

while / for
在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
for循环格式：

for 临时变量 in 列表或者字符串等可迭代对象:
    循环满足条件时执行的代码

range 可以生成数字供 for 循环遍历,它可以传递三个参数，分别表示 起始、结束和步长。
包含起始位置，不包含结束的数值
默认是从0开始的，默认步长是1

>>> range(2, 10, 3)
[2, 5, 8]
>>> for x in range(2, 10, 3):
...     print(x)
...
2
5
8

在Python中，break和continue只能用于循环语句中。
break和continue在嵌套循环中使用时，只对最内层循环有效。

在Python中，循环语句还可以和else语句联合使用

while 判断条件:
  条件成立时，循环体代码
else:
  如果循环一直没有被中断，才会被执行；如果执行中跳出了，那么这里不会被执行

从上述结构中，我们可以看出，在非死循环中，正常情况下else里的语句都是会被执行的。那这个else语句到底有什么作用呢？一般情况下，循环语句和else共同出现时，在循环语句里都会配合break语句来使用。

转义字符

\r表示回退回本行开头，打印后面的内容

print("abcd\r  efg")
-----
print("abcd\n  efg")
输出：
  efg
-----
abcd
  efg

字符串

获取地址的函数 id()
is 运算符比较的是地址
从下面例子可以看出，相同字符串共用内存，相当于java中的字符串常量池

s1 = 'hello'
s2 = s1
s3 = 'hello'
print(id(s1))
print(id(s2))
print(id(s3))
print(s1 is s2)

s1 = 'word'
print(s1, s2, s3)
输出：
2035658937544
2035658937544
2035658937544
True
word hello hello

字符串索引可以从前往后，从0开始到len(s) - 1
可以从后往前，从-len(s)开始到-1

切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔，也可以控制方向，负数表示从右向左取。

find，rfind，index，rindex

find查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.

语法格式：（[]是可以加的内容）
S.find(sub[, start[, end]]) -> int
end同样不会被包括

mystr = '今天天气好晴朗，处处好风光呀好风光'
id_f = mystr.find('风')  # 11
print(mystr.find('好风光'))  # 10 '好风光'第一次出现时，'好'所在的位置
print(mystr.find('你好'))  # -1  '你好'不存在，返回 -1
print(mystr.find('风', 12))  # 15 从下标12开始查找'风',找到风所在的位置试15
print(mystr.find('风', 11))  # 11 从下标12开始查找'风',找到风所在的位置试11
print(mystr.find('风',0,id_f)) # -1 从下标0开始到10查找"风", 未找到，返回 -1

rfind是从右往左找

index跟find()方法一样，只不过，find方法未找到时，返回-1,而index未找到时，会报一个异常。

startwith、endswith

startswith判断字符串是否以指定内容开始。 语法格式:

S.startswith(prefix[, start[, end]]) -> bool

isalpha、isdigit、isalnum、isspace

isalpha判断字符串是否是纯字母。
isdigit判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False.
isalnum判断是否由数字和字母组成。只要出现了非数字和字母，就返回False.
isspace如果 mystr 中只包含空格，则返回 True，否则返回 False.
isupper 判断字符串中的字母是否全部是大写字母
islower 判断字符串中的字母是否全部是小写字母，如下

s = "123dddd"
print(s.islower()) # True

count

返回 str在start和end之间 在 mystr里面出现的次数。

语法格式:
S.count(sub[, start[, end]]) -> int

replace

替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。
replace(old, new, count)

mystr = '今天天气好晴朗，处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr)  # 今天天气好晴朗，处处好风光呀好风光  原字符串未改变！
print(newstr)  # 今天天气坏晴朗，处处坏风光呀坏风光 得到的新字符串里，'好'被修改成了'坏'

newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的'好'被替换成了'坏'

如果一次要替换两个词，可以通过1.正则表达式来处理 2.循环+列表

分割split

内容分隔主要涉及到split,rsplit, splitlines,partition和rpartition四个方法。

split(‘分隔符’, maxsplit) 返回结果是一个列表，切maxsplit刀

splitlines按照行分隔，返回一个包含各行作为元素的列表。

partition把mystr以str分割成三部分,str前，str和str后，三部分组成一个元组

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.partition('好'))  # ('今天天气', '好', '晴朗，处处好风光呀好风光')

大小写转换

修改大小写的功能只对英文有效，主要包括，首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.

空格处理，左对齐右对齐居中对齐

常用的是strip，去除左右两边的空格

ljust返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)。

str = 'hello'
print(str.ljust(10))  # hello     在右边补了五个空格

rjust返回指定长度的字符串，并在左侧使用空白字符补全(右对齐)。

str = 'hello'
print(str.rjust(10))  #      hello在左边补了五个空格

center返回指定长度的字符串，并在两端使用空白字符补全(居中对齐)

str = 'hello'
print(str.center(10))  #  hello   两端加空格，让内容居中

lstrip删除 mystr 左边的空白字符。

mystr = '    he   llo      '
print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留

rstrip删除 mystr 右边的空白字符。

mystr = '    he   llo      '
print(str.rstrip())  #    he   llo右边的空格被删除

strip删除两断的空白字符。

str = '    he   llo      '
print(str.strip())  #he   llo

字符串拼接

把参数进行遍历，取出参数里的每一项，然后再在后面加上mystr

语法格式:
S.join(iterable)

示例:

mystr = 'a'
print(mystr.join('hxmdq'))  #haxamadaq  把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
print(mystr.join(['hi','hello','good']))  #hiahelloagood

作用：可以把列表或者元组快速的转变成为字符串，并且以指定的字符分隔。

txt = '_'
print(txt.join(['hi','hello','good'])) #hi_hello_good
print(txt.join(('good','hi','hello'))) #good_hi_hello

字符串运算符

1. 字符串和字符串之间能够使用加法运算符，作用是将两个字符串拼接成为一个字符串。例如:‘hello’ + 'world’的结果是 ‘helloworld’
2. 字符串和数字之间可以做乘法运算，结果是将指定的字符串重复多次。例如:‘hello’*2的结果是hellohello
3. 字符串和字符串之间，如果使用比较运算符进行计算，会获取字符对应的编码，然后进行比较。
4. 除上述几种运算符以外，字符串默认不支持其他运算符。

字符串格式化format

1. str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field，从而完成字符串的格式化。
2. 替换字段 由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成，即一般形式为 {字段名!转换字段:格式说明符}。
3. 字段名分为简单字段名 simple field name 和复合字段名 compound field name。而转换字段和格式说明符都是可选的。

简单字段名

简单字段名由三中写法:

省略字段名:{}
使用非负十进制整数{0}
变量名{name}

省略字段名

大括号内省略字段名，传递位置参数。
替换字段形式： {}
注意：大括号个数可以少于位置参数的个数，反之不然。

# 省略字段名传递位置参数
print('我叫{}，今年{}岁。'.format('小明', 18))
"""
我叫小明，今年18岁。
"""

# 大括号个数可以少于位置参数的个数
print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
"""
我爱吃香蕉和苹果。
"""

# 大括号个数多于位置参数的个数则会报错
# print('我还吃{}和{}。'.format('西红柿'))
"""
IndexError: tuple index out of range
"""

数字字段名

可以通过数字形式的简单字段名传递位置参数。

数字必须是大于等于 0 的整数。
带数字的替换字段可以重复使用。
数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组，通过字段名中的数字进行取值。即 {0} 等价于 tuple[0]，所以大括号内的数字不能越界。

# 通过数字形式的简单字段名传递位置参数
print('身高{0}，家住{1}。'.format(1.8, '铜锣湾'))
"""
身高1.8，家住铜锣湾
"""

# 数字形式的简单字段名可以重复使用。
print('我爱{0}。\n她今年{1}。\n我也爱{0}。'.format('阿香', 17))
"""
我爱阿香。
她今年17。
我也爱阿香。
"""

# 体会把所有位置参数整体当成元组来取值
print('阿香爱吃{1}、{3}和{0}。'.format(
    '榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
"""
阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
"""

# 尝试一下越界错误
# print('{1}'.format('错误用法'))
"""
IndexError: tuple index out of range
"""

变量字段名

使用变量名形式的简单字段名传递关键字参数。

关键字参数的位置可以随意调换。

# 使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
"""
我大哥是阿飞，今年20岁。
"""

# 关键字参数的顺序可以随意调换
print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))
"""
我大哥是阿飞，今年20岁。
"""

简单字段名的混合使用

混合使用数字形式和变量名形式的字段名，可以同时传递位置参数和关键字参数。
关键字参数必须位于位置参数之后。
混合使用时可以省略数字。
省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。

# 混合使用数字形式和变量名形式的字段名
# 可以同时传递位置参数和关键字参数
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))
"""
这是一个关于小明、阿飞和阿香的故事。
"""

# 但是关键字参数必须位于位置参数之后
# print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    # '小明', girl='阿香' , '阿飞'))
"""
SyntaxError: positional argument follows keyword argument
"""

# 数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))

# 但是省略字段名不能和数字形式的字段名同时出现
# print('这是一个关于{}、{1}和{girl}的故事。'.format(
#     '小明', '阿飞', girl='阿香'))
"""
ValueError: cannot switch from automatic field numbering to manual field specification
"""

2.1.5 使用元组和字典传参

str.format() 方法还可以使用 *元组 和 **字典 的形式传参，两者可以混合使用。 位置参数、关键字参数、*元组 和 **字典 也可以同时使用，但是要注意，位置参数要在关键字参数前面，*元组 要在 **字典 前面。

# 使用元组传参
infos = '钢铁侠', 66, '小辣椒'
print('我是{}，身价{}亿。'.format(*infos))
"""
我是钢铁侠，身家66亿。
"""
print('我是{2}，身价{1}亿。'.format(*infos))
"""
我是小辣椒，身家66亿。
"""

# 使用字典传参
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name}，我怕{weakness}。'.format(**venom))
"""
我是毒液，我怕火。
"""

# 同时使用元组和字典传参
hulk = '绿巨人', '拳头'
captain = {'name': '美国队长', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
print('我是{name}, 我怕{1}。'.format(*hulk, **captain))

"""
我是绿巨人, 我怕盾。
我是美国队长, 我怕拳头。
"""

# 同时使用位置参数、元组、关键字参数、字典传参
# 注意：
# 位置参数要在关键字参数前面
# *元组要在**字典前面
tup = '鹰眼',
dic = {'weapon': '箭'}
text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
text = text.format(
    *tup, '黑寡妇', weakness='男人', **dic)
print(text)
"""
我是黑寡妇，我怕男人。我是鹰眼，我用箭。
"""

复合字段名

同时使用了数字和变量名两种形式的字段名就是复合字段名。
复合字段名支持两种操作符：

. 点号
[] 中括号

使用 . 点号

传递位置参数
替换字段形式：{数字.属性名}
只有一个替换字段的时候可以省略数字

class Person(object):
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
p = Person('zhangsan',18,'female')
print('姓名是{0.name},年龄是{0.age},性别是{0.gender}'.format(p))
print('姓名是{.name}'.format(p))  # 只有一个替换字段时，可以省略数字

使用[]中括号

用列表传递位置参数
用元组传递位置参数
用字典传递位置参数

# 中括号用法：用列表传递位置参数
infos = ['阿星', 9527]
food = ['霸王花', '爆米花']
print('我叫{0[0]}，警号{0[1]}，爱吃{1[0]}。'.format(
    infos, food))
"""
我叫阿星，警号9527，爱吃霸王花。
"""

# 中括号用法：用元组传递位置参数
food = ('僵尸', '脑子')
print('我叫{0[0]}，年龄{1}，爱吃{0[1]}。'.format(
    food, 66))
"""
我叫僵尸，年龄66，爱吃脑子。
"""

# 中括号用法：用字典传递位置参数
dic = dict(name='阿星', pid=9527)
print('我是{[name]}！'.format(
    dic))
# 多个替换字段，不能省略数字
print('我是{0[name]}，警号{0[pid]}。'.format(
    dic))
"""
我是阿星！
我是阿星，警号9527。
"""

转换字段

转换字段 conversion field 的取值有三种，前面要加 !：

s：传递参数之前先对参数调用 str()
r：传递参数之前先对参数调用 repr()
a：传递参数之前先对参数调用 ascii()

ascii() 函数类似 repr() 函数，返回一个可以表示对象的字符串。 但是对于非 ASCII 字符，使用 \x，\u 或者 \U 转义。

# 转换字段
print('I am {!s}!'.format('Bruce Lee 李小龙'))
print('I am {!r}!'.format('Bruce Lee 李小龙'))
print('I am {!a}!'.format('Bruce Lee 李小龙'))
"""
I am Bruce Lee 李小龙!
I am 'Bruce Lee 李小龙'!
I am 'Bruce Lee \u674e\u5c0f\u9f99'!
"""