Python snake case or camel case

Most Common Programming Case Types

When working with computers—specifically while programming—you’ll inevitably find yourself naming things (one of the two hard things in computer science). A major factor of being successful in naming is knowing the type of case you want to use so that you can have a consistent convention per project/workspace. If you’re writing software, you’ll come across at least one of these in a languages specification for how it’s written. Some languages (Go, particularly) rely heavily on you knowing the difference between two of them and using them correctly!

What You’ll Learn

• The most common case types:
  • Camel case
  • Snake case
  • Kebab case
  • Pascal case
  • Upper case (with snake case)
  • naming files for a computer (my recommended best practice)
  • writing code with Go
  • writing code with Ruby
  • writing code with JavaScript
  • writing code with Python

  camelCase

  camelCase must (1) start with a lowercase letter and (2) the first letter of every new subsequent word has its first letter capitalized and is compounded with the previous word.

  An example of camel case of the variable camel case var is camelCaseVar .

  snake_case

  snake_case is as simple as replacing all spaces with a «_» and lowercasing all the words. It’s possible to snake_case and mix camelCase and PascalCase but imo, that ultimately defeats the purpose.

  An example of snake case of the variable snake case var is snake_case_var .

  kebab-case

  kebab-case is as simple as replacing all spaces with a «-» and lowercasing all the words. It’s possible to kebab-case and mix camelCase and PascalCase but that ultimately defeats the purpose.

  An example of kebab case of the variable kebab case var is kebab-case-var .

  PascalCase

  PascalCase has every word starts with an uppercase letter (unlike camelCase in that the first word starts with a lowercase letter).

  An example of pascal case of the variable pascal case var is PascalCaseVar .

  Note: It’s common to see this confused for camel case, but it’s a separate case type altogether.

  UPPER_CASE_SNAKE_CASE

  UPPER_CASE_SNAKE_CASE is replacing all the spaces with underscores and converting all the letters to capitals.

  an example of upper case snake case of the variable upper case snake case var is UPPER_CASE_SNAKE_CASE_VAR .

  Which case type should I use?

  Now that you know the various case types, let’s tackle an example of my recommended best practice for filenames and when to use each case for Go, JavaScript, Python & Ruby.

  What convention should I use when naming files?

  Recommendation: always snake case

  When naming files, it’s important to ask «what’s the lowest common denominator?» If you’re not opinionated, I’ve found I’ve had the most success with snake case because it’s the least likely to create a problem across filesystems and keeps filenames readable for «my_awesome_file».

  If you’re a Mac user or work with Mac users, it’s a good practice to always use lowercase. Mac’s have an HFS+ filesystem and since HFS+ is not case sensitive, it can read «MyFile» or «myfile» as «myfile».

  My predominant argument for this stems from a particularly insidious «bug» I saw when I was running a CI/CD (continuous integration/continuous delivery) cluster. A CI job failed with «file not found: mycomponent.js» during a build for a React project. The developer swore the file was in the project’s source, and as I dug through it, I noticed they had an import for «mycomponenet.js» but the file was named «MyComponent.js» (for a React project, where PascalCase is the convention for naming component files). Due to the way HFS+ handles file casing, it happily accepted that «MyComponent.js» was «mycomponent.js» at the time the developer (using a Mac) was writing the code, but ath the time the Unix based CI server was building it, it would fail because it expected exact casing to find the file.

  Go Conventions

  Go is the language where it’s most critical to pay attention to case type conventions. The language decides whether a variable, field or method should be available to a package caller by if the name starts with a capital or lowercase letter.

  • Pascal case is required for exporting fields and methods in Go
  • Camel case is required for internal fields and methods in Go

  package casetypes type ExportedStruct

  In the above example, ExportedStruct is available to package callers for casetypes and unexportedField is only available to methods on ExportedStruct .

  Javascript Conventions

  • Camel case for variables and methods.
  • Pascal case for types and classes in JavaScript.
  • Upper case snake case for constants.

  React Conventions

  I write enough React and it’s unique enougn that it’s worth calling out conventions here as a subsection:

  Ruby Conventions

  • Pascal case is used for classes and modules in Ruby.
  • Snake case for symbols, methods and variables.
  • Upper case snake case for constants.

  Python Conventions

  • Snake case for method names and instance variables (PEP8).
  • Upper case snake case for constants.

  Other Conventions

  • kebab case in Lisp.
  • kebab case in HTTP URLs ( most-common-programming-case-types/ ).
  • snake case in JSON property keys.

  Quick Comparison Table

  Case Type	Example
  Original Variable as String	some awesome var
  Camel Case	someAwesomeVar
  Snake Case	some_awesome_var
  Kebab Case	some-awesome-var
  Pascal Case	SomeAwesomeVar
  Upper Case Snake Case	SOME_AWESOME_VAR

  Now that you’ve been introduced to the most common case types, you’re prepared to hop into most of the popular languages and know what conventions to keep when you’re writing your own code!

  Источник

  Стили написания составных слов в программировании

  Перевод статьи Чейза Адамса «Most Common Programming Case Types».

  

  Работая с компьютерами и, в особенности, занимаясь программированием, вы неизбежно столкнетесь с необходимостью давать названия чему-либо. Это одно из двух самых сложных дел в информатике.

  Чтобы именование было успешным, самое главное – определиться со стилем написания составных слов. Это важно для поддержания последовательности в пределах одного проекта или рабочего пространства. Если вы занимаетесь созданием программного обеспечения, то в спецификации своего языка вы можете встретить указание на определенный стиль. Некоторые языки (в частности, Go) очень полагаются на ваше знание разницы между стилями и правильное их использование.

  Прочитав эту статью, вы узнаете:

  Самые распространенные стили написания составных слов:

  • Camel case
  • Snake case
  • Kebab case
  • Pascal case
  • Upper case (в сочетании со snake case).

  Как их использовать в следующих ситуациях:

  • выбор названия файлов для компьютера (рекомендуемый мной подход)
  • программирование на Go
  • программирование на Ruby
  • программирование на JavaScript
  • программирование на Python

  camelCase

  camelCase должен начинаться со строчной буквы, а первая буква каждого последующего слова должна быть заглавной. Все слова при этом пишутся слитно между собой.

  Пример camelCase для имени переменной camel case var – camelCaseVar.

  snake_case

  Чтобы писать в стиле snake_case, нужно просто заменить пробелы знаками подчеркивания. Все слова при этом пишутся строчными буквами. Можно использовать snake_case, смешивая его с camelCase и PascalCase, но, как по мне, при этом теряется сам смысл этого стиля.

  Пример snake_case для имени переменной snake case var – snake_case_var.

  kebab-case

  kebab-case похож на snake_case, только в нем пробелы заменяются на дефисы. Слова также пишутся строчными буквами. Опять же, его можно смешивать с camelCase и PascalCase, но в этом нет смысла.

  Пример kebab-case для переменной kebab case var – kebab-case-var.

  PascalCase

  В PascalCase каждое слово начинается с заглавной буквы (в отличие от camelCase, где первое слово начинается со строчной).

  Пример PascalCase для переменной pascal case var – PascalCaseVar.

  Примечание: этот стиль часто путают с camelCase, но это, тем не менее, отдельный стиль.

  UPPER_CASE_SNAKE_CASE

  В UPPER_CASE_SNAKE_CASE все слова пишутся заглавными буквами, а пробелы заменяются знаками подчеркивания.

  Пример UPPER_CASE_SNAKE_CASE для переменной upper case snake case var – UPPER_CASE_SNAKE_CASE_VAR.

  

  Как выбрать стиль написания составных слов?

  Теперь, когда вы ознакомились с различными стилями, давайте рассмотрим примеры их использования для выбора названий файлов и для программирования на разных языках. Я буду указывать вариант, который, как мне кажется, является лучшим подходом.

  Какого соглашения придерживаться, выбирая имена для файлов?

  Совет: всегда snake_case

  При выборе названий для файлов важно задавать вопрос: «Каков наименьший общий знаменатель?». Если у вас нет собственного мнения на этот счет, поделюсь своим опытом. Лучший результат у меня всегда получался при использовании snake_case. В этом случае название файла сохраняет читабельность и при этом вряд ли приведет к каким-либо проблемам в файловой системе.

  Если вы пользуетесь Mac или работаете с пользователями Mac, будет хорошей идеей всегда использовать только строчные буквы. Файловая система Mac – HFS+, а поскольку она нечувствительна к регистру, то файлы «MyFile» и «myfile» не будут различаться.

  Мой главный аргумент в пользу этого подхода связан с особенно коварным «багом», который я видел при запуске CI/CD (непрерывной интеграции/непрерывной доставки) кластера. Во время сборки проекта на React в работе CI возник сбой с сообщением «файл не найден: mycomponent.js». Разработчик божился, что этот файл был в исходниках проекта.

  Я обнаружил, что они импортировали «mycomponenet.js», но файл назывался «MyComponent.js». Это ведь был проект на React, где для наименований компонентов файлов используется именно PascalCase. Поскольку HFS+ не различает регистры, файл «MyComponent.js» был успешно принят за «mycomponent.js», когда разработчик писал код (на Mac). Но когда выполнялась сборка на сервере CI (а он был на основе Unix), возник сбой, потому что система искала точное соответствие названия.

  Соглашения Go

  В Go критически важно быть внимательным к соглашениям о наименованиях. Этот язык определяет доступность переменной, поля или метода для вызова исходя из того, со строчной или заглавной буквы начинается имя.

  • PascalCase обязателен для экспортируемых полей и методов.
  • camelCase обязателен для внутренних полей и методов.

  type ExportedStruct unexportedField string
  >[/code]

  В этом примере ExportedStruct доступен для пакетных вызовов для casetypes, а unexportedField доступен только для методов ExportedStruct.

  Соглашения JavaScript

  • camelCase для переменных и методов.
  • PascalCase для типов и классов.
  • UPPER_CASE_SNAKE_CASE для констант.

  Соглашения React

  У меня довольно большой опыт программирования на React, к тому же он довольно уникален, поэтому заслуживает своего подраздела:

  Соглашения Ruby

  • PascalCase используется для классов и модулей.
  • snake_case – для символов, методов и переменных.
  • UPPER_CASE_SNAKE_CASE – для констант.

  Соглашения Python

  Другие соглашения

  • kebab-case в Lisp.
  • kebab-case в HTTP URL (most-common-programming-case-types/).
  • snake_case в ключах свойств JSON.

  Таблица для быстрого сравнения

  Стиль написания	Пример
  Исходное написание имени переменной	some awesome var
  Camel Case	someAwesomeVar
  Snake Case	some_awesome_var
  Kebab Case	some-awesome-var
  Pascal Case	SomeAwesomeVar
  Upper Case Snake Case	SOME_AWESOME_VAR

  Теперь, зная самые распространенные стили написания, вам будет легче определиться, какой использовать при написании своего кода!

  Источник

  Читайте также:  Римские цифры перевод python