基础-基本语法

• 基础-基本语法
  • 数值
  • 保留关键字
  • 重新赋值
  • 多重赋值
  • 字符串
  • 内置函数
  • 方法
  • 函数
  • 条件分支-if
  • 逻辑运算
  • 逐步创建函数
  • 列表
  • For循环
  • While循环
  • 集合
  • 字典
  • 字典词典
  • 推导式

数值

• 即使一个整数可以整除另一个整数，其结果也将是一个浮点数
• 一个整数和一个浮点数的运算将生成一个浮点数
• 如需要生成一个浮点数，包括一个小数点即可！如果数字本身是一个整数，也没关系，甚至不必在小数点之后添加任何内容 ````python

  33. 33.0 ````

• 手动将一个数值类型转换为另一个数值类型，这可通过 int() 和 float() 构造这些类型的新对象来实现。
• 将一个浮点数转换成整数时，小数点后的部分会被去除，而不是数学中的四舍五入。
• 变量名中只能使用普通字母、数字和下划线，且以字母或下划线开头。
• 命名规则还是遵循驼峰命名法，变量用下划线间隔，函数用驼峰。
• 行尾不需要以分号结束。
• 以4个空格为缩进，标识代码块，不需要花括号{}。
• 定义变量可以直接写，并赋值，而不需要前面加关键字，比如var、define之类的。

name = Jackson
age = 23

运算符：

• 除了基本的+-*/运算符, **表示n次方，比如 3**2表示3的2次方。
• python中没有其他语言的i++，但是可以用 i+=1来表示，同样的 -=、*=、/=同样的有效。
• //取整，%取余。

保留关键字

False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
assert     else       import     pass
break      except     in         raise

重新赋值

  >>> manila_pop += 1675 # manila_pop = manila_pop + 1675
  >>> manila_pop -= 250 # manila_pop = manila_pop - 1675
  >>> manila_pop *= 0.9 # manila_pop = manila_pop * 0.9
  >>> manila_area /=  2 # manila_area = manila_area / 2

多重赋值

也可以在一行代码中为两个变量赋值：

savings = 514.86
salary = 320.51

savings, salary = 514.86, 320.51

字符串

• +可用于字符串的拼接。
• 字符串中包含引号的时候，最外层用单引号，内层字符串用双引号，区分开来。
• 使用反斜杠（\）来转义

内置函数

• 字符串长度：len()，如果括号内的内容不是字符类型，则会报错
• 变量类型：type()
• 数据类型转换：int()、str()、float()、bool()

方法

语法：name_string.islower()

和javascript类似。

• 判断字符串是否全部小写：islower()
• 返回字符串中子字符串出现的次数：count() ````py

  "One fish, two fish, red fish, blue fish.".count('fish') 4 ````

• 字符串转换成小写：lower()
• 字符串转换成大写：upper()
• 字符串每个单词的首字母大写：title()
• 去除字符串左侧空格：lstrip()
• 去除字符串右侧空格：rstrip()
• 去除字符串两侧空格：strip()

函数

语法：

def cylinder_volume(height, radius):
    pi = 3.14159
    return height * pi * radius ** 2

函数头 1. def 关键字表示以下代码即函数定义。 2. def 后跟的是函数的名称，在这个例子中是cylinder_volume。函数名称应该是一个单词，中间没有空格，这是为什么在这个名称中有一个下划线。 3. 函数定义第一行的最后一个元素是函数所需的参数（函数名的规则与变量名的规则相同）。函数的参数是调用函数时传入的值；在函数体中将使用这些参数。用逗号隔开参数，并将它们放在一对括号中。如果编写一个不带参数的函数，应使用一对空括号 ()。函数定义的第一行以冒号 : 结尾。

这是一个不带参数的函数示例：

def print_greeting():
    print('Hello World!')

函数体 4. 使用四个空格缩进函数体。函数体是函数发挥作用的载体。我们可以在函数体内引用参数变量，以及定义新的变量。在此定义的pi 变量是一个局部变量，这意味着它只能在cylinder_volume函数的函数体中使用。在其他地方尝试访问该变量会导致错误。 5. 使用 return关键字可获取函数结果。return之后的表达式值是函数的输出值。 6. 在这个示例中，我们返回一个表达式（即圆柱体积的公式）的值。请注意，在表达式的其他部分之前先计算radius ** 2，原因是在数学运算顺序中，先运算乘方，再运算乘法。（也就是说，增加一对额外括号不会有什么坏处，特别是在涉及大量数学运算的表达式中，首先计算哪个运算可能会出现混淆。返回height * pi * (radius ** 2)即可。）如果不用表达式返回值，替代方法是提前在函数体中计算体积，然后将其存储在名为 volume 的变量中，这将使我们可以 return volume。

记录函数

文档字符串（也称为 "docstrings"）。Docstrings 是一种用于解释函数目的以及如何使用的注释。

用三个引号（"""）包围起来:

def population_density(population, land_area):
    """Calculate the population density of an area.

    population: int. The population of the area
    land_area: int or float. This function is unit-agnostic, if you pass
               in values in terms of square km or square miles the
               function will return a density in those units.
    """
    return population / land_area

条件分支-if

条件分支表达式：

1. if 关键字表示此行是条件表达式。
2. if 之后是 phone_balance < 10，即要检查的条件。这部分是布尔表达式 —— 一个计算结果为 True 或 False 的表达式。
3. 条件表达式（或 "if 语句"）以冒号结尾。
4. 该行后面是一个缩进的代码块，在此种情况中：

  phone_balance += 10
  bank_balance -= 10

如果布尔表达式的计算结果为 True，那么将执行该缩进的代码块。如果布尔表达式的计算结果为 False，则不会执行缩进的代码块。

扩展：if、elif 和 else

else语法：

  if number % 2 == 0:
      print("The number " + str(number) + " is even.")
  else:
      print("The number " + str(number) + " is odd.")

else 关键字后面总是跟一个冒号，不需要布尔表达式 —— if 语句后的布尔表达式计算结果为 False 时，即可运行。

elif语法：

  def garden_calendar(season):
    if season == "spring":
        print("time to plant the garden!")
    elif season == "summer":
        print("time to water the garden!")
    elif season == "autumn" or season == "fall":
        print("time to harvest the garden!")
    elif season == "winter":
        print("time to stay indoors and drink tea!")
    else:
        print("I don't recognize that season")

逻辑运算

与或非在Python中的表达用：and、or、not

例子：

if is_raining and is_sunny:
    print("Is there a rainbow?")

if (not do_not_email) and (location == "USA" or location == "CAN"):
    send_email()

• 判断一个值是否为真可以用：if ran_away:
• 判断一个值是否为假：if not ran_away:
• 不要使用：if ran_away == true 或者if ran_away == false

逐步创建函数

一个完整的功能或者函数，逐步的将其拆解成小的功能模块或者函数，然后组装起来。

创建函数时的步骤：

1. 收集函数的要求，包括输入和输出
2. 首先将该过程分成简单的语言，而不是代码。
3. 创建执行每个步骤的函数框架，包括尚未定义的帮助函数。 在这个阶段，调整步骤使编码更容易
4. 创建帮助函数框架。
5. 填写帮助函数的代码，测试其功能。
6. 完成主函数的代码，调用每个帮助函数，并测试其功能。

列表

列表：相当于C或者JS里面的数组，类型为：list。

列表切片：从列表中切出来一部分，生成新的列表。

例子：

  #从months的第6位开始切，到第9位结束。
  q3 = months[6:9]
  print(q3)
  ['July', 'August', 'September']
  print(months)
  ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']

切片简化方式：

有几种切片快捷方式可以简化常见情况。如果想获得一个从原始列表开头开始的分片，或者一个在在原始列表的末尾结束的分片，可以省略如下所示的开始或结束索引：

>>> first_half = months[:6]
>>> print(first_half)
['January', 'February', 'March', 'April', 'May', 'June']
>>> second_half = months[6:]
>>> print(second_half)
['July', 'August', 'September', 'October', 'November', 'December']

如果列表数量不确定，只想获取最后的几个，可以用负数：

>>> months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
>>> last_three_months = months[-3:]
>>> print(last_three_months)
['October', 'November', 'December']

list和string、float、int都是一种数据类型，和字符串类似，list和string都支持索引、切片、len函数和in运算。

>>> sample_string = "And Now For Something Completely Different"
>>> sample_list = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']
>>> sample_string[4]
'N'
>>> sample_list[4]
'Terry'
>>> sample_string[12:21]
'Something'
>>> sample_list[2:4]
['Terry', 'Eric']
>>> len(sample_string)
42
>>> len(sample_list)
6
>>> 'thing' in sample_string
True
>>> 'Rowan' in sample_list
False

可变性（Mutability）:表示对象是否可被修改。列表是可变的，字符串式不可变。

1. 这里字符串的不可变指的不是字符串的变量不能再被赋值，而是字符串的内容不能被修改。
2. 另一点，将列表a赋值给列表b以后，修改列表a的某个值后，列表b的对应的值也被修改了。

修改列表：

sentence2 = ["I", "wish", "to", "register", "a", "complaint", "."]
sentence2[6]="!"    #["I", "wish", "to", "register", "a", "complaint", "!"]
sentence2[0:2] = ["We", "want"]   #表示从第0位开始，替换2个，结果是：["We", "want", "to", "register", "a", "complaint", "."]

sample_list = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']
new_list = sample_list
print(sample_list)
print(new_list)

sample_list[1] = 'Jackson'
sample_list[2] = 250
print(sample_list)
print(new_list)

#输出结果：
['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']
['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']

['Graham', 'Jackson', 250, 'Eric', 'Terry', 'Michael']
['Graham', 'Jackson', 250, 'Eric', 'Terry', 'Michael']

使用列表：

• len(some_list)返回列表元素个数。
• max(some_list)返回列表中最大的元素。 如果内容都是数字，则返回最大的数字，如果内容都是字符串，则返回按字母排序的最后一个元素。如果列表包含了不同类型的元素，则报错。
• min(some_list)返回列表中最小的元素。
• sorted(some_list)按从小到大的顺序返回some_list的副本，同时some_list的内容不变。元素为字符串时，按字母排序。 如果要按从大到小来排序，则加个参数：sorted(some_list,reverse=True)
• some_list.sort()是从小到大排序，把结果再赋给some_list，也就是原列表的内容被改变了。 当然，如果给sort()加个参数：some_list.sort(reverse=True)则将其按从大到小排序。

连接列表join：

join 将一个列表作为参数，返回一个由分隔符字符串连接列表元素组成的字符串。在这个示例中，我们使用字符串 \n 作为分隔符，以便使每个元素之间有一个换行符。

被链接列表的元素只能是字符串。 元素之间必须用逗号(,)间隔开，不能用空格，否则会引入问题。

>>> nautical_directions = "\n".join(["fore", "aft", "starboard", "port"])
>>> print(nautical_directions)
fore
aft
starboard
port

分隔符换成其他字符串，不用\n:

>>> names = ["García", "O'Kelly", "Davis"]
>>> "-".join(names)
"García-O'Kelly-Davis"

追加到列表append:

#追加字符
>>> some=['s','d','f','h']
> >>> some.append('x')
>>> some
['s', 'd', 'f', 'h', 'x']
#*************************************
#追加数字
>>> some=[1,5,3]
>>> some.append(6)
>>> some
[1, 5, 3, 6]
#*************************************
#混合
>>> some.append('a')
>>> some
[1, 5, 3, 6, 'a']

For循环

1. for 关键字表示这是一个 for 循环。
2. 该行的其余部分指定了正在迭代的内容。names 是这个 for 循环迭代的列表。name 是该循环的迭代变量。针对 names 中的每个元素， for 循环的主体都会被执行一次，迭代变量 name 可用于循环体，从而指代循环当前处理的元素。
3. 一个 for 循环的主体缩进了四个空格，并针对列表中的每个元素运行一次。

关于命名的注释。你可以采用自己喜欢的任何方式命名迭代变量。但是这个例子展现了一个常见模式，即列表 names 的名称是以 "s" 结尾的复数，而迭代变量是没有 "s" 的单数。以此模式命名列表和迭代变量，可以使其他程序员更轻松地了解不同的变量。

这里的迭代变量名是自定义的，不需要和列表名有关系，但通常要考虑是其他的程序员能够一眼看出来。

实现C语言中的for循环的功能，需要用到range():

for number in range(x):
    pass

range 函数需要一个参数，一个整数 n，并返回一个从零到 n-1 的数字序列。 for number in range(2)即表示x=0/1，循环两次；x初始值为0，循环x次

把列表的内容输出成html的ul列表：

def html_list(input_list):
    output_list = []
    output_list.append('<ul>')
    for index in range(len(input_list)):
        output_list.append('<li>' + str(input_list[index]) + '</li>')
    output_list.append('</ul>')
    output_lists = "\n".join(output_list)
    return output_lists

def html_list(list_items):
    HTML_string = "<ul>\n"
    for item in list_items:
        HTML_string += "<li>{}</li>\n".format(item)
    HTML_string += "</ul>"
    return HTML_string

两种方法的区别： 1. 前者返回的内容还是个列表，经过格式化，形式上是一段ul。 2. 后者输出的直接是一段html格式的代码。 3. 前者需要转换原始列表为字符串格式，后者不需要。

如果for后面的变量不需要在循环体中使用，可以写为 for _ in range(10): 这里的 _ 是一个虚拟变量，在循环体中不会被使用到。

While循环

1. While 关键字表明这是一个 while 循环
2. 接下来是一个测试表达式，在该示例中为 sum(hand) <= 21。如果此表达式为真，将执行循环体。运行循环体后再次判断测试表达式。该过程重复判断测试表达式并运行循环，直到表达式变为 false。
3. 循环体缩进了四个空格。循环体应该以某种方式修改测试表达式中的变量。如果测试表达式的值从不改变，结果将是一个无限循环！在该示例中，循环体将数字追加到 hand 列表中，因此增加了 sum(hand) 的值。

示例代码说明，hand中的数量（sum(hand)）少于等于17的时候，从card_deck中减掉(card_deck.pop())一个，加到hand (hand.append())中。

break停止:

使程序跳出循环。

切片、break、for的应用：

需求是从headlines中内容拼出一个字符串刚好140个字符，元素之间用空格间隔开。

headlines = ["Local Bear Eaten by Man",
             "Legislature Announces New Laws",
             "Peasant Discovers Violence Inherent in System",
             "Cat Rescues Fireman Stuck in Tree",
             "Brave Knight Runs Away",
             "Papperbok Review: Totally Triffic"]

news_ticker = ""

#我的方案：
index = 0
for index in range(len(headlines)):
    if len(news_ticker + " " + headlines[index]) > 140:
        break
    else:
        news_ticker = news_ticker + headlines[index]+ " "
        print("debug:news_ticker is:{}".format(news_ticker))
        print("debug:news_ticker's length is:{}".format(len(news_ticker)))
print('debug:index is: {}'.format(index))
print("debug:Add backspace length is:{}".format(len(news_ticker)))
i = 0
while len(news_ticker) + 1 <= 140:
    news_ticker = news_ticker + headlines[index][i]
    i += 1
print("debug:final length is:{}".format(len(news_ticker)))
print("debug:final news is:{}".format(news_ticker))

#更简洁的方案：
for headline in headlines:
    news_ticker += headline + " "
    if len(news_ticker) >= 140:
        news_ticker = news_ticker[:140]
        break

#我的方案：是在加，判断离终点还有多远，先到达最近的，然后再一个字符一个字符的增加。
#系统方案：先加满（刚好超出一个元素），然后从新的字符串上截取（切片）0-140的内容。
#后者代码更简洁，我忽略了一个字符串的切片方案。

集合

集合和列表类似，也是存储元素的数据结构，但集合是唯一元素的集合，且元素没有任何特定排序。

集合中的元素都是唯一的、不重复的；集合中元素的排序都是随机的，每次print，顺序都会改变，新添加进来的元素位置也是随机的。

创建集合：

#创建空集合：
my_set = set()

#根据已有列表创建集合：
country = ['JJJ', 'FFF', 'MMM', 'AAA', 'MMM', 'JJJ', 'JJJ', 'AAA', 'SSS', 'OOO', 'NNN', 'DDD']
country_set = set(country)

print(country)
#结果是：['JJJ', 'FFF', 'MMM', 'AAA', 'MMM', 'JJJ', 'JJJ', 'AAA', 'SSS', 'OOO', 'NNN', 'DDD']
print(country_set)
#结果是：['JJJ', 'FFF', 'MMM', 'AAA', 'SSS', 'OOO', 'NNN', 'DDD']

集合同样支持in运算符：

>>> 'JJJ' in country
True
>>> 'JJJ' in country_set
True
>>>

集合支持添加元素，但和列表不同，使用的不是append，而是add方法：

>>> country_set.add('BBBBB')
>>> country_set
{'MMM', 'AAA', 'OOO', 'NNN', 'JJJ', 'BBBBB', 'DDD', 'SSS', 'FFF'}

集合也有一个与列表一样的 pop 方法。从集合 pop 一个元素时，一个随机元素被删除，但集合不同于列表，是无序的，所以没有 "最后一个元素"。

可以使用与迭代列表一样的方法通过 for 循环迭代集合

>>> country_set.pop()
'MMM'
>>> country_set
{'AAA', 'OOO', 'NNN', 'JJJ', 'BBBBB', 'DDD', 'SSS', 'FFF'}

集合的使用：

# 方法一：
squares = set()
squares_2 = set()
def nearest_square(limit):
    answer = 0
    while (answer+1)**2 < limit:
        answer += 1
    return answer**2
for x in range(2,2000):
    squares.add(nearest_square(x))
print(squares)

# 方法二：
n = 1
while n**2 <= 2000:
    squares_2.add(n**2)
    n += 1
print(squares_2)

两种方法比较：①后一种代码更简洁；②计算机运行的次数更少，前一种需要运算1+2+...+2000次，后者只需1999次，后者更加节省资源；

字典

字典是复合型（我定义的）的数据结构，存储的是元素对：键（Key） 和 值（Value）。

类似json也支持对象嵌套。

# 创建字典：
>>> elements = {'hydrogen': 1, 'helium': 2, 'carbon': 6}
# 查找字典中的值：
>>> print(element['carbon'])
6
# 插入字典：
>>> elements['lithium'] = 3
>>> print(elements['lithium'])
3

检查字典中是否包含某个键：

if 'mithril' in elements:
    print("That's a real element!")
else:
    print("There's no such element!")

另一种方法 get。get 用于在字典中查找值，但不同于方括号，如果不存在这个键，get 返回None (或选择的默认值)，而不像方括号那样会报key error。

>>> elements.get('dilithium')
None
# 查找不到值的时候报指定的字符串提示。
>>> elements.get('kryptonite', 'There\'s no such element!')
"There's no such element!"

列表、集合、字典三者表达上分别用[]、()、{}; 迭代：就是通过for循环遍历列表、集合或者字典，表达方式：for name in names:

字典词典

说白了，就是json，字典嵌套字典。

#创建
elements = {'hydrogen': {'number': 1, 'weight': 1.00794, 'symbol': 'H'},
            'helium': {'number': 2, 'weight': 4.002602, 'symbol': 'He'}}
#通过方括号查看
>>> print(elements['helium'])
{'number': 2, 'symbol': 'He', 'weight': 4.002602}
#通过``get``查找：获取**氦字典**
>>> elements.get('helium')
{'number': 2, 'weight': 4.002602, 'symbol': 'He'}
#get嵌套查找子对象（键值的子键）：**原子量**
>>> elements.get('helium').get('number')
2
#查找不存在的键
>>> print(elements.get('unobtainium', 'There\'s no such element!'))
There's no such element!

推导式

• 格式

# 列表推导式
# 中括号包裹，条件可为空
[元素内容 for i in range(x,y) 条件]

# 字典推导式
# 花括号包裹，条件可为空
{key:value for i in range(x,y) 条件}

• 样例

# 生成数字1-10的列表
print([i for i in range(1, 11)])
# 运行结果
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 以1-10的平方为列表
print([i*i for i in range(1, 11)])
# 运行结果
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#生成1-10中偶数的平方的列表
print([i*i for i in range(1, 11) if(i % 2) == 0])
# 运行结果
[4, 16, 36, 64, 100]